test/java/nio/file/Files/SBC.java
Print this page
@@ -21,11 +21,11 @@
* questions.
*/
/* @test
* @bug 4313887
- * @summary Unit test for java.nio.file.Path.newByteChannel
+ * @summary Unit test for java.nio.file.Files.newByteChannel
* @library ..
*/
import java.nio.ByteBuffer;
import java.nio.file.*;
@@ -73,28 +73,28 @@
Path file = dir.resolve("foo");
// CREATE
try {
// create file (no existing file)
- file.newByteChannel(CREATE, WRITE).close();
- if (file.notExists())
+ Files.newByteChannel(file, CREATE, WRITE).close();
+ if (Files.notExists(file))
throw new RuntimeException("File not created");
// create file (existing file)
- file.newByteChannel(CREATE, WRITE).close();
+ Files.newByteChannel(file, CREATE, WRITE).close();
// create file where existing file is a sym link
if (supportsLinks) {
- Path link = dir.resolve("link").createSymbolicLink(file);
+ Path link = Files.createSymbolicLink(dir.resolve("link"), file);
try {
// file already exists
- link.newByteChannel(CREATE, WRITE).close();
+ Files.newByteChannel(link, CREATE, WRITE).close();
// file does not exist
- file.delete();
- link.newByteChannel(CREATE, WRITE).close();
- if (file.notExists())
+ Files.delete(file);
+ Files.newByteChannel(link, CREATE, WRITE).close();
+ if (Files.notExists(file))
throw new RuntimeException("File not created");
} finally {
TestUtil.deleteUnchecked(link);
}
@@ -105,32 +105,32 @@
}
// CREATE_NEW
try {
// create file
- file.newByteChannel(CREATE_NEW, WRITE).close();
- if (file.notExists())
+ Files.newByteChannel(file, CREATE_NEW, WRITE).close();
+ if (Files.notExists(file))
throw new RuntimeException("File not created");
// create should fail
try {
SeekableByteChannel sbc =
- file.newByteChannel(CREATE_NEW, WRITE);
+ Files.newByteChannel(file, CREATE_NEW, WRITE);
sbc.close();
throw new RuntimeException("FileAlreadyExistsException not thrown");
} catch (FileAlreadyExistsException x) { }
// create should fail
if (supportsLinks) {
Path link = dir.resolve("link");
Path target = dir.resolve("thisDoesNotExist");
- link.createSymbolicLink(target);
+ Files.createSymbolicLink(link, target);
try {
try {
SeekableByteChannel sbc =
- file.newByteChannel(CREATE_NEW, WRITE);
+ Files.newByteChannel(file, CREATE_NEW, WRITE);
sbc.close();
throw new RuntimeException("FileAlreadyExistsException not thrown");
} catch (FileAlreadyExistsException x) { }
} finally {
@@ -143,21 +143,17 @@
TestUtil.deleteUnchecked(file);
}
// CREATE_NEW + SPARSE
try {
- SeekableByteChannel sbc = file
- .newByteChannel(CREATE_NEW, WRITE, SPARSE);
- try {
+ try (SeekableByteChannel sbc = Files.newByteChannel(file, CREATE_NEW, WRITE, SPARSE)) {
final long hole = 2L * 1024L * 1024L * 1024L;
sbc.position(hole);
write(sbc, "hello");
long size = sbc.size();
if (size != (hole + 5))
throw new RuntimeException("Unexpected size");
- } finally {
- sbc.close();
}
} finally {
TestUtil.deleteUnchecked(file);
}
}
@@ -165,37 +161,27 @@
// test APPEND option
static void appendTests(Path dir) throws Exception {
Path file = dir.resolve("foo");
try {
// "hello there" should be written to file
- SeekableByteChannel sbc = file
- .newByteChannel(CREATE_NEW, WRITE, APPEND);
- try {
+ try (SeekableByteChannel sbc = Files.newByteChannel(file, CREATE_NEW, WRITE, APPEND)) {
write(sbc, "hello ");
sbc.position(0L);
write(sbc, "there");
- } finally {
- sbc.close();
}
// check file
- Scanner s = new Scanner(file);
- try {
+ try (Scanner s = new Scanner(file)) {
String line = s.nextLine();
if (!line.equals("hello there"))
throw new RuntimeException("Unexpected file contents");
- } finally {
- s.close();
}
// check that read is not allowed
- sbc = file.newByteChannel(APPEND);
- try {
+ try (SeekableByteChannel sbc = Files.newByteChannel(file, APPEND)) {
sbc.read(ByteBuffer.allocate(100));
} catch (NonReadableChannelException x) {
- } finally {
- sbc.close();
}
} finally {
// clean-up
TestUtil.deleteUnchecked(file);
}
@@ -203,44 +189,31 @@
// test TRUNCATE_EXISTING option
static void truncateExistingTests(Path dir) throws Exception {
Path file = dir.resolve("foo");
try {
- SeekableByteChannel sbc =
- file.newByteChannel(CREATE_NEW, WRITE);
- try {
+ try (SeekableByteChannel sbc = Files.newByteChannel(file, CREATE_NEW, WRITE)) {
write(sbc, "Have a nice day!");
- } finally {
- sbc.close();
}
// re-open with truncate option
// write short message and check
- sbc = file.newByteChannel(WRITE, TRUNCATE_EXISTING);
- try {
+ try (SeekableByteChannel sbc = Files.newByteChannel(file, WRITE, TRUNCATE_EXISTING)) {
write(sbc, "Hello there!");
- } finally {
- sbc.close();
}
- Scanner s = new Scanner(file);
- try {
+ try (Scanner s = new Scanner(file)) {
String line = s.nextLine();
if (!line.equals("Hello there!"))
throw new RuntimeException("Unexpected file contents");
- } finally {
- s.close();
}
// re-open with create + truncate option
// check file is of size 0L
- sbc = file.newByteChannel(WRITE, CREATE, TRUNCATE_EXISTING);
- try {
+ try (SeekableByteChannel sbc = Files.newByteChannel(file, WRITE, CREATE, TRUNCATE_EXISTING)) {
long size = ((FileChannel)sbc).size();
if (size != 0L)
throw new RuntimeException("File not truncated");
- } finally {
- sbc.close();
}
} finally {
// clean-up
TestUtil.deleteUnchecked(file);
@@ -250,18 +223,19 @@
// test NOFOLLOW_LINKS option
static void noFollowLinksTests(Path dir) throws Exception {
if (!supportsLinks)
return;
- Path file = dir.resolve("foo").createFile();
+ Path file = Files.createFile(dir.resolve("foo"));
try {
// ln -s foo link
- Path link = dir.resolve("link").createSymbolicLink(file);
+ Path link = dir.resolve("link");
+ Files.createSymbolicLink(link, file);
// open with NOFOLLOW_LINKS option
try {
- link.newByteChannel(READ, LinkOption.NOFOLLOW_LINKS);
+ Files.newByteChannel(link, READ, LinkOption.NOFOLLOW_LINKS);
throw new RuntimeException();
} catch (IOException x) {
} finally {
TestUtil.deleteUnchecked(link);
}
@@ -274,13 +248,11 @@
// test size/truncate/position methods
static void sizeTruncatePositionTests(Path dir) throws Exception {
Path file = dir.resolve("foo");
try {
- SeekableByteChannel sbc = file
- .newByteChannel(CREATE_NEW, READ, WRITE);
- try {
+ try (SeekableByteChannel sbc = Files.newByteChannel(file, CREATE_NEW, READ, WRITE)) {
if (sbc.size() != 0L)
throw new RuntimeException("Unexpected size");
// check size
write(sbc, "hello");
@@ -298,91 +270,76 @@
sbc.position(2L).truncate(3L);
if (sbc.size() != 3L)
throw new RuntimeException("Unexpected size");
if (sbc.position() != 2L)
throw new RuntimeException("Unexpected position");
- } finally {
- sbc.close();
}
} finally {
TestUtil.deleteUnchecked(file);
}
}
// Windows specific options for the use by applications that really want
// to use legacy DOS sharing options
static void dosSharingOptionTests(Path dir) throws Exception {
- Path file = dir.resolve("foo").createFile();
+ Path file = Files.createFile(dir.resolve("foo"));
try {
- SeekableByteChannel ch;
-
// no sharing
- ch = file.newByteChannel(READ,
- NOSHARE_READ, NOSHARE_WRITE, NOSHARE_DELETE);
+ try (SeekableByteChannel ch = Files.newByteChannel(file, READ, NOSHARE_READ,
+ NOSHARE_WRITE, NOSHARE_DELETE))
+ {
try {
- try {
- file.newByteChannel(READ);
+ Files.newByteChannel(file, READ);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
try {
- file.newByteChannel(WRITE);
+ Files.newByteChannel(file, WRITE);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
try {
- file.delete();
+ Files.delete(file);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
- } finally {
- ch.close();
}
// read allowed
- ch = file.newByteChannel(READ, NOSHARE_WRITE, NOSHARE_DELETE);
+ try (SeekableByteChannel ch = Files.newByteChannel(file, READ, NOSHARE_WRITE, NOSHARE_DELETE)) {
+ Files.newByteChannel(file, READ).close();
try {
- file.newByteChannel(READ).close();
- try {
- file.newByteChannel(WRITE);
+ Files.newByteChannel(file, WRITE);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
try {
- file.delete();
+ Files.delete(file);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
- } finally {
- ch.close();
}
// write allowed
- ch = file.newByteChannel(READ, NOSHARE_READ, NOSHARE_DELETE);
+ try (SeekableByteChannel ch = Files.newByteChannel(file, READ, NOSHARE_READ, NOSHARE_DELETE)) {
try {
- try {
- file.newByteChannel(READ);
+ Files.newByteChannel(file, READ);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
- file.newByteChannel(WRITE).close();
+ Files.newByteChannel(file, WRITE).close();
try {
- file.delete();
+ Files.delete(file);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
- } finally {
- ch.close();
}
// delete allowed
- ch = file.newByteChannel(READ, NOSHARE_READ, NOSHARE_WRITE);
+ try (SeekableByteChannel ch = Files.newByteChannel(file, READ, NOSHARE_READ, NOSHARE_WRITE)) {
try {
- try {
- file.newByteChannel(READ);
+ Files.newByteChannel(file, READ);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
try {
- file.newByteChannel(WRITE);
+ Files.newByteChannel(file, WRITE);
throw new RuntimeException("Sharing violation expected");
} catch (IOException ignore) { }
- file.delete();
- } finally {
- ch.close();
+ Files.delete(file);
}
} finally {
TestUtil.deleteUnchecked(file);
}
@@ -391,16 +348,16 @@
// invalid combinations of options
static void badCombinations(Path dir) throws Exception {
Path file = dir.resolve("bad");
try {
- file.newByteChannel(READ, APPEND);
+ Files.newByteChannel(file, READ, APPEND);
throw new RuntimeException("IllegalArgumentException expected");
} catch (IllegalArgumentException x) { }
try {
- file.newByteChannel(WRITE, APPEND, TRUNCATE_EXISTING);
+ Files.newByteChannel(file, WRITE, APPEND, TRUNCATE_EXISTING);
throw new RuntimeException("IllegalArgumentException expected");
} catch (IllegalArgumentException x) { }
}
// unsupported operations
@@ -407,57 +364,63 @@
static void unsupportedOptions(Path dir) throws Exception {
Path file = dir.resolve("bad");
OpenOption badOption = new OpenOption() { };
try {
- file.newByteChannel(badOption);
+ Files.newByteChannel(file, badOption);
throw new RuntimeException("UnsupportedOperationException expected");
} catch (UnsupportedOperationException e) { }
try {
- file.newByteChannel(READ, WRITE, badOption);
+ Files.newByteChannel(file, READ, WRITE, badOption);
throw new RuntimeException("UnsupportedOperationException expected");
} catch (UnsupportedOperationException e) { }
}
// null handling
static void nullTests(Path dir) throws Exception {
Path file = dir.resolve("foo");
try {
- file.newByteChannel((OpenOption[])null);
+ OpenOption[] opts = { READ, null };
+ Files.newByteChannel((Path)null, opts);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException x) { }
try {
+ Files.newByteChannel(file, (OpenOption[])null);
+ throw new RuntimeException("NullPointerException expected");
+ } catch (NullPointerException x) { }
+
+ try {
OpenOption[] opts = { READ, null };
- file.newByteChannel(opts);
+ Files.newByteChannel(file, opts);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException x) { }
try {
- file.newByteChannel((Set<OpenOption>)null);
+ Files.newByteChannel(file, (Set<OpenOption>)null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException x) { }
try {
- Set<OpenOption> opts = new HashSet<OpenOption>();
+ Set<OpenOption> opts = new HashSet<>();
opts.add(READ);
opts.add(null);
- file.newByteChannel(opts);
+ Files.newByteChannel(file, opts);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException x) { }
try {
EnumSet<StandardOpenOption> opts = EnumSet.of(READ);
- file.newByteChannel(opts, (FileAttribute[])null);
+ Files.newByteChannel(file, opts, (FileAttribute[])null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException x) { }
try {
EnumSet<StandardOpenOption> opts = EnumSet.of(READ);
FileAttribute[] attrs = { null };
- file.newByteChannel(opts, attrs);
+ Files.newByteChannel(file, opts, attrs);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException x) { }
}
static void write(WritableByteChannel wbc, String msg) throws IOException {