270 lines
9.4 KiB
Java
270 lines
9.4 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 2018, 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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
import java.io.ByteArrayOutputStream;
|
||
|
|
import java.io.IOException;
|
||
|
|
import java.nio.charset.Charset;
|
||
|
|
import static java.nio.charset.StandardCharsets.US_ASCII;
|
||
|
|
import static java.nio.charset.StandardCharsets.ISO_8859_1;
|
||
|
|
import static java.nio.charset.StandardCharsets.UTF_8;
|
||
|
|
import java.nio.file.Files;
|
||
|
|
import java.nio.file.OpenOption;
|
||
|
|
import java.nio.file.Path;
|
||
|
|
import java.nio.file.Paths;
|
||
|
|
import java.nio.file.StandardOpenOption;
|
||
|
|
import static java.nio.file.StandardOpenOption.APPEND;
|
||
|
|
import java.util.Random;
|
||
|
|
import java.util.concurrent.Callable;
|
||
|
|
import static org.testng.Assert.assertTrue;
|
||
|
|
import static org.testng.Assert.fail;
|
||
|
|
import org.testng.annotations.AfterClass;
|
||
|
|
import org.testng.annotations.BeforeClass;
|
||
|
|
import org.testng.annotations.DataProvider;
|
||
|
|
import org.testng.annotations.Test;
|
||
|
|
|
||
|
|
/* @test
|
||
|
|
* @bug 8201276
|
||
|
|
* @build ReadWriteString PassThroughFileSystem
|
||
|
|
* @run testng ReadWriteString
|
||
|
|
* @summary Unit test for methods for Files readString and write methods.
|
||
|
|
* @key randomness
|
||
|
|
*/
|
||
|
|
@Test(groups = "readwrite")
|
||
|
|
public class ReadWriteString {
|
||
|
|
|
||
|
|
private static final OpenOption OPTION_CREATE = StandardOpenOption.CREATE;
|
||
|
|
// data for text files
|
||
|
|
private static final String EN_STRING = "The quick brown fox jumps over the lazy dog";
|
||
|
|
private static final String JA_STRING = "\u65e5\u672c\u8a9e\u6587\u5b57\u5217";
|
||
|
|
// malformed input: a high surrogate without the low surrogate
|
||
|
|
static char[] illChars = {
|
||
|
|
'\u00fa', '\ud800'
|
||
|
|
};
|
||
|
|
|
||
|
|
static byte[] data = getData();
|
||
|
|
|
||
|
|
static byte[] getData() {
|
||
|
|
try {
|
||
|
|
String str1 = "A string that contains ";
|
||
|
|
String str2 = " , an invalid character for UTF-8.";
|
||
|
|
|
||
|
|
ByteArrayOutputStream baos = new ByteArrayOutputStream();
|
||
|
|
baos.write(str1.getBytes());
|
||
|
|
baos.write(0xFA);
|
||
|
|
baos.write(str2.getBytes());
|
||
|
|
return baos.toByteArray();
|
||
|
|
} catch (IOException ex) {
|
||
|
|
return null; //shouldn't happen
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// file used by most tests
|
||
|
|
private Path tmpfile;
|
||
|
|
|
||
|
|
|
||
|
|
/*
|
||
|
|
* DataProvider for malformed write test. Provides the following fields:
|
||
|
|
* file path, malformed input string, charset
|
||
|
|
*/
|
||
|
|
@DataProvider(name = "malformedWrite")
|
||
|
|
public Object[][] getMalformedWrite() throws IOException {
|
||
|
|
Path path = Files.createTempFile("malformedWrite", null);
|
||
|
|
return new Object[][]{
|
||
|
|
{path, "\ud800", null}, //the default Charset is UTF_8
|
||
|
|
{path, "\u00A0\u00A1", US_ASCII},
|
||
|
|
{path, "\ud800", UTF_8},
|
||
|
|
{path, JA_STRING, ISO_8859_1},
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* DataProvider for illegal input test
|
||
|
|
* Writes the data in ISO8859 and reads with UTF_8, expects MalformedInputException
|
||
|
|
*/
|
||
|
|
@DataProvider(name = "illegalInput")
|
||
|
|
public Object[][] getIllegalInput() throws IOException {
|
||
|
|
Path path = Files.createTempFile("illegalInput", null);
|
||
|
|
return new Object[][]{
|
||
|
|
{path, data, ISO_8859_1, null},
|
||
|
|
{path, data, ISO_8859_1, UTF_8}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
@BeforeClass
|
||
|
|
void setup() throws IOException {
|
||
|
|
tmpfile = Files.createTempFile("readWriteString", null);
|
||
|
|
}
|
||
|
|
|
||
|
|
@AfterClass
|
||
|
|
void cleanup() throws IOException {
|
||
|
|
Files.deleteIfExists(tmpfile);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Verifies that NPE is thrown when one of the parameters is null.
|
||
|
|
*/
|
||
|
|
@Test
|
||
|
|
public void testNulls() {
|
||
|
|
Path path = Paths.get(".");
|
||
|
|
String s = "abc";
|
||
|
|
|
||
|
|
checkNullPointerException(() -> Files.readString((Path) null));
|
||
|
|
checkNullPointerException(() -> Files.readString((Path) null, UTF_8));
|
||
|
|
checkNullPointerException(() -> Files.readString(path, (Charset) null));
|
||
|
|
|
||
|
|
checkNullPointerException(() -> Files.writeString((Path) null, s, OPTION_CREATE));
|
||
|
|
checkNullPointerException(() -> Files.writeString(path, (CharSequence) null, OPTION_CREATE));
|
||
|
|
checkNullPointerException(() -> Files.writeString(path, s, (OpenOption[]) null));
|
||
|
|
|
||
|
|
checkNullPointerException(() -> Files.writeString((Path) null, s, UTF_8, OPTION_CREATE));
|
||
|
|
checkNullPointerException(() -> Files.writeString(path, (CharSequence) null, UTF_8, OPTION_CREATE));
|
||
|
|
checkNullPointerException(() -> Files.writeString(path, s, (Charset) null, OPTION_CREATE));
|
||
|
|
checkNullPointerException(() -> Files.writeString(path, s, UTF_8, (OpenOption[]) null));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Verifies the readString and write String methods. Writes to files Strings
|
||
|
|
* of various sizes, with/without specifying the Charset, and then compares
|
||
|
|
* the result of reading the files.
|
||
|
|
*/
|
||
|
|
@Test
|
||
|
|
public void testReadWrite() throws IOException {
|
||
|
|
int size = 0;
|
||
|
|
while (size < 16 * 1024) {
|
||
|
|
testReadWrite(size, null, false);
|
||
|
|
testReadWrite(size, null, true);
|
||
|
|
testReadWrite(size, UTF_8, false);
|
||
|
|
testReadWrite(size, UTF_8, true);
|
||
|
|
size += 1024;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Verifies that IOException is thrown (as specified) when giving a malformed
|
||
|
|
* string input.
|
||
|
|
*
|
||
|
|
* @param path the path to write
|
||
|
|
* @param s the string
|
||
|
|
* @param cs the Charset
|
||
|
|
* @throws IOException if the input is malformed
|
||
|
|
*/
|
||
|
|
@Test(dataProvider = "malformedWrite", expectedExceptions = IOException.class)
|
||
|
|
public void testMalformedWrite(Path path, String s, Charset cs) throws IOException {
|
||
|
|
path.toFile().deleteOnExit();
|
||
|
|
if (cs == null) {
|
||
|
|
Files.writeString(path, s, OPTION_CREATE);
|
||
|
|
} else {
|
||
|
|
Files.writeString(path, s, cs, OPTION_CREATE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Verifies that IOException is thrown when reading a file using the wrong
|
||
|
|
* Charset.
|
||
|
|
*
|
||
|
|
* @param path the path to write and read
|
||
|
|
* @param data the data used for the test
|
||
|
|
* @param csWrite the Charset to use for writing the test file
|
||
|
|
* @param csRead the Charset to use for reading the file
|
||
|
|
* @throws IOException when the Charset used for reading the file is incorrect
|
||
|
|
*/
|
||
|
|
@Test(dataProvider = "illegalInput", expectedExceptions = IOException.class)
|
||
|
|
public void testMalformedRead(Path path, byte[] data, Charset csWrite, Charset csRead) throws IOException {
|
||
|
|
path.toFile().deleteOnExit();
|
||
|
|
String temp = new String(data, csWrite);
|
||
|
|
Files.writeString(path, temp, csWrite, OPTION_CREATE);
|
||
|
|
String s;
|
||
|
|
if (csRead == null) {
|
||
|
|
s = Files.readString(path);
|
||
|
|
} else {
|
||
|
|
s = Files.readString(path, csRead);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void checkNullPointerException(Callable<?> c) {
|
||
|
|
try {
|
||
|
|
c.call();
|
||
|
|
fail("NullPointerException expected");
|
||
|
|
} catch (NullPointerException ignore) {
|
||
|
|
} catch (Exception e) {
|
||
|
|
fail(e + " not expected");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private void testReadWrite(int size, Charset cs, boolean append) throws IOException {
|
||
|
|
StringBuilder sb = new StringBuilder(size);
|
||
|
|
String expected;
|
||
|
|
String str = generateString(size);
|
||
|
|
Path result;
|
||
|
|
if (cs == null) {
|
||
|
|
result = Files.writeString(tmpfile, str);
|
||
|
|
} else {
|
||
|
|
result = Files.writeString(tmpfile, str, cs);
|
||
|
|
}
|
||
|
|
|
||
|
|
//System.out.println(result.toUri().toASCIIString());
|
||
|
|
assertTrue(result == tmpfile);
|
||
|
|
if (append) {
|
||
|
|
if (cs == null) {
|
||
|
|
Files.writeString(tmpfile, str, APPEND);
|
||
|
|
} else {
|
||
|
|
Files.writeString(tmpfile, str, cs, APPEND);
|
||
|
|
}
|
||
|
|
assertTrue(Files.size(tmpfile) == size * 2);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
if (append) {
|
||
|
|
sb.append(str).append(str);
|
||
|
|
expected = sb.toString();
|
||
|
|
} else {
|
||
|
|
expected = str;
|
||
|
|
}
|
||
|
|
|
||
|
|
String read;
|
||
|
|
if (cs == null) {
|
||
|
|
read = Files.readString(result);
|
||
|
|
} else {
|
||
|
|
read = Files.readString(result, cs);
|
||
|
|
}
|
||
|
|
//System.out.println("chars read: " + read.length());
|
||
|
|
//System.out.println(read);
|
||
|
|
//System.out.println("---end---");
|
||
|
|
assertTrue(read.equals(expected), "String read not the same as written");
|
||
|
|
}
|
||
|
|
|
||
|
|
static final char[] CHARS = "abcdefghijklmnopqrstuvwxyz \r\n".toCharArray();
|
||
|
|
StringBuilder sb = new StringBuilder(512);
|
||
|
|
Random random = new Random();
|
||
|
|
|
||
|
|
private String generateString(int size) {
|
||
|
|
sb.setLength(0);
|
||
|
|
for (int i = 0; i < size; i++) {
|
||
|
|
char c = CHARS[random.nextInt(CHARS.length)];
|
||
|
|
sb.append(c);
|
||
|
|
}
|
||
|
|
|
||
|
|
return sb.toString();
|
||
|
|
}
|
||
|
|
}
|