/*
* Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/* @test
* @bug 7006126
* @summary Unit test for methods for Files readAllBytes, readAllLines and
* and write methods.
*/
import java.nio.file.*;
import static java.nio.file.Files.*;
import java.io.*;
import java.util.*;
import java.nio.charset.*;
public class BytesAndLines {
static final Random rand = new Random();
static final Charset US_ASCII = Charset.forName("US-ASCII");
public static void main(String[] args) throws IOException {
testReadAndWriteBytes();
testReadLines();
testWriteLines();
}
/**
* Test readAllBytes(Path) and write(Path, byte[], OpenOption...)
*/
static void testReadAndWriteBytes() throws IOException {
// exercise methods with various sizes
testReadAndWriteBytes(0);
for (int i=0; i<100; i++) {
testReadAndWriteBytes(rand.nextInt(32000));
}
// NullPointerException
Path file = Paths.get("foo");
List<String> lines = Collections.emptyList();
try {
readAllBytes(null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
write(null, lines, Charset.defaultCharset());
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
write(file, null, Charset.defaultCharset());
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
write(file, lines, null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
write(file, lines, Charset.defaultCharset(), (OpenOption[])null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
OpenOption[] opts = { null };
write(file, lines, Charset.defaultCharset(), opts);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
}
static void testReadAndWriteBytes(int size) throws IOException {
Path path = createTempFile("blah", null);
try {
boolean append = rand.nextBoolean();
byte[] b1 = new byte[size];
rand.nextBytes(b1);
byte[] b2 = (append) ? new byte[size] : new byte[0];
rand.nextBytes(b2);
// write method should create file if it doesn't exist
if (rand.nextBoolean())
delete(path);
// write bytes to file
Path target = write(path, b1);
assertTrue(target==path, "Unexpected path");
assertTrue(size(path) == b1.length, "Unexpected file size");
// append bytes to file (might be 0 bytes)
write(path, b2, StandardOpenOption.APPEND);
assertTrue(size(path) == b1.length + b2.length, "Unexpected file size");
// read entire file
byte[] read = readAllBytes(path);
// check bytes are correct
byte[] expected;
if (append) {
expected = new byte[b1.length + b2.length];
System.arraycopy(b1, 0, expected, 0, b1.length);
System.arraycopy(b2, 0, expected, b1.length, b2.length);
} else {
expected = b1;
}
assertTrue(Arrays.equals(read, expected),
"Bytes read not the same as bytes written");
} finally {
deleteIfExists(path);
}
}
/**
* Test readAllLines(Path,Charset)
*/
static void testReadLines() throws IOException {
Path tmpfile = createTempFile("blah", "txt");
try {
List<String> lines;
// zero lines
assertTrue(size(tmpfile) == 0, "File should be empty");
lines = readAllLines(tmpfile, US_ASCII);
assertTrue(lines.isEmpty(), "No line expected");
// one line
byte[] hi = { (byte)'h', (byte)'i' };
write(tmpfile, hi);
lines = readAllLines(tmpfile, US_ASCII);
assertTrue(lines.size() == 1, "One line expected");
assertTrue(lines.get(0).equals("hi"), "'Hi' expected");
// two lines using platform's line separator
List<String> expected = Arrays.asList("hi", "there");
write(tmpfile, expected, US_ASCII);
assertTrue(size(tmpfile) > 0, "File is empty");
lines = readAllLines(tmpfile, US_ASCII);
assertTrue(lines.equals(expected), "Unexpected lines");
// MalformedInputException
byte[] bad = { (byte)0xff, (byte)0xff };
write(tmpfile, bad);
try {
readAllLines(tmpfile, US_ASCII);
throw new RuntimeException("MalformedInputException expected");
} catch (MalformedInputException ignore) { }
// NullPointerException
try {
readAllLines(null, US_ASCII);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
readAllLines(tmpfile, null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
} finally {
delete(tmpfile);
}
}
/**
* Test write(Path,Iterable<? extends CharSequence>,Charset,OpenOption...)
*/
static void testWriteLines() throws IOException {
Path tmpfile = createTempFile("blah", "txt");
try {
// write method should create file if it doesn't exist
if (rand.nextBoolean())
delete(tmpfile);
// zero lines
Path result = write(tmpfile, Collections.<String>emptyList(), US_ASCII);
assert(size(tmpfile) == 0);
assert(result == tmpfile);
// two lines
List<String> lines = Arrays.asList("hi", "there");
write(tmpfile, lines, US_ASCII);
List<String> actual = readAllLines(tmpfile, US_ASCII);
assertTrue(actual.equals(lines), "Unexpected lines");
// append two lines
write(tmpfile, lines, US_ASCII, StandardOpenOption.APPEND);
List<String> expected = new ArrayList<String>();
expected.addAll(lines);
expected.addAll(lines);
assertTrue(expected.size() == 4, "List should have 4 elements");
actual = readAllLines(tmpfile, US_ASCII);
assertTrue(actual.equals(expected), "Unexpected lines");
// UnmappableCharacterException
try {
String s = "\u00A0\u00A1";
write(tmpfile, Arrays.asList(s), US_ASCII);
throw new RuntimeException("UnmappableCharacterException expected");
} catch (UnmappableCharacterException ignore) { }
// NullPointerException
try {
write(null, lines, US_ASCII);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
write(tmpfile, null, US_ASCII);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
write(tmpfile, lines, null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
write(tmpfile, lines, US_ASCII, (OpenOption[])null);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
try {
OpenOption[] opts = { (OpenOption)null };
write(tmpfile, lines, US_ASCII, opts);
throw new RuntimeException("NullPointerException expected");
} catch (NullPointerException ignore) { }
} finally {
delete(tmpfile);
}
}
static void assertTrue(boolean expr, String errmsg) {
if (!expr)
throw new RuntimeException(errmsg);
}
}