test/jdk/java/nio/file/Files/BytesAndLines.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2011, 2013, 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 8020669 8024788 8019526
  * @build BytesAndLines PassThroughFileSystem
  * @run testng BytesAndLines
  * @summary Unit test for methods for Files readAllBytes, readAllLines and
  *     and write methods.
  * @key randomness
  */

 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.nio.file.OpenOption;
 import static java.nio.file.StandardOpenOption.*;
 import java.nio.charset.Charset;
 import java.nio.charset.CharacterCodingException;
 import java.nio.charset.MalformedInputException;
 import java.nio.charset.UnmappableCharacterException;
 import static java.nio.charset.StandardCharsets.*;
 import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 import java.util.Random;
 import java.util.concurrent.Callable;
 import java.io.IOException;

 import org.testng.annotations.AfterClass;
 import org.testng.annotations.BeforeClass;
 import org.testng.annotations.Test;
 import static org.testng.Assert.*;

 @Test(groups = "unit")
 public class BytesAndLines {

     // 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";

     // used for random byte content
     private static Random RAND = new Random();

     // file used by most tests
     private Path tmpfile;

     @BeforeClass
     void setup() throws IOException {
         tmpfile = Files.createTempFile("blah", null);
     }

     @AfterClass
     void cleanup() throws IOException {
         Files.deleteIfExists(tmpfile);
     }

     /**
      * Returns a byte[] of the given size with random content
      */
     private byte[] genBytes(int size) {
         byte[] arr = new byte[size];
         RAND.nextBytes(arr);
         return arr;
     }

     /**
      * Exercise NullPointerException
      */
     public void testNulls() {
         Path file = Paths.get("foo");
         byte[] bytes = new byte[100];
         List<String> lines = Collections.emptyList();

         checkNullPointerException(() -> Files.readAllBytes(null));

         checkNullPointerException(() -> Files.write(null, bytes));
         checkNullPointerException(() -> Files.write(file, (byte[])null));
         checkNullPointerException(() -> Files.write(file, bytes, (OpenOption[])null));
         checkNullPointerException(() -> Files.write(file, bytes, new OpenOption[] { null } ));

         checkNullPointerException(() -> Files.readAllLines(null));
         checkNullPointerException(() -> Files.readAllLines(file, (Charset)null));
         checkNullPointerException(() -> Files.readAllLines(null, Charset.defaultCharset()));

         checkNullPointerException(() -> Files.write(null, lines));
         checkNullPointerException(() -> Files.write(file, (List<String>)null));
         checkNullPointerException(() -> Files.write(file, lines, (OpenOption[])null));
         checkNullPointerException(() -> Files.write(file, lines, new OpenOption[] { null } ));
         checkNullPointerException(() -> Files.write(null, lines, Charset.defaultCharset()));
         checkNullPointerException(() -> Files.write(file, null, Charset.defaultCharset()));
         checkNullPointerException(() -> Files.write(file, lines, (Charset)null));
         checkNullPointerException(() -> Files.write(file, lines, Charset.defaultCharset(), (OpenOption[])null));
         checkNullPointerException(() -> Files.write(file, lines, Charset.defaultCharset(), new OpenOption[] { null } ));
     }

     private void checkNullPointerException(Callable<?> c) {
         try {
             c.call();
             fail("NullPointerException expected");
         } catch (NullPointerException ignore) {
         } catch (Exception e) {
             fail(e + " not expected");
         }
     }

     /**
      * Exercise Files.readAllBytes(Path) on varied file sizes
      */
     public void testReadAllBytes() throws IOException {
         int size = 0;
         while (size <= 16*1024) {
             testReadAllBytes(size);
             size += 512;
         }
     }

     private void testReadAllBytes(int size) throws IOException {
         // write bytes to file (random content)
         byte[] expected = genBytes(size);
         Files.write(tmpfile, expected);

         // check expected bytes are read
         byte[] read = Files.readAllBytes(tmpfile);
         assertTrue(Arrays.equals(read, expected), "Bytes read not the same as written");
     }

     /**
      * Linux specific test to exercise Files.readAllBytes on /proc. This is
      * special because file sizes are reported as 0 even though the file
      * has content.
      */
     public void testReadAllBytesOnProcFS() throws IOException {
         // read from procfs
         if (System.getProperty("os.name").equals("Linux")) {
             Path statFile = Paths.get("/proc/self/stat");
             byte[] data = Files.readAllBytes(statFile);
             assertTrue(data.length > 0, "Files.readAllBytes('" + statFile + "') failed to read");
         }
     }

     /**
      * Exercise Files.readAllBytes(Path) on custom file system. This is special
      * because readAllBytes was originally implemented to use FileChannel
      * and so may not be supported by custom file system providers.
      */
     public void testReadAllBytesOnCustomFS() throws IOException {
         Path myfile = PassThroughFileSystem.create().getPath("myfile");
         try {
             int size = 0;
             while (size <= 1024) {
                 byte[] b1 = genBytes(size);
                 Files.write(myfile, b1);
                 byte[] b2 = Files.readAllBytes(myfile);
                 assertTrue(Arrays.equals(b1, b2), "bytes not equal");
                 size += 512;
             }
         } finally {
             Files.deleteIfExists(myfile);
         }
     }

     /**
      * Exercise Files.write(Path, byte[], OpenOption...) on various sizes
      */
     public void testWriteBytes() throws IOException {
         int size = 0;
         while (size < 16*1024) {
             testWriteBytes(size, false);
             testWriteBytes(size, true);
             size += 512;
         }
     }

     private void testWriteBytes(int size, boolean append) throws IOException {
         byte[] bytes = genBytes(size);
         Path result = Files.write(tmpfile, bytes);
         assertTrue(result == tmpfile);
         if (append) {
             Files.write(tmpfile, bytes, APPEND);
             assertTrue(Files.size(tmpfile) == size*2);
         }

         byte[] expected;
         if (append) {
             expected = new byte[size << 1];
             System.arraycopy(bytes, 0, expected, 0, bytes.length);
             System.arraycopy(bytes, 0, expected, bytes.length, bytes.length);
         } else {
             expected = bytes;
         }

         byte[] read = Files.readAllBytes(tmpfile);
         assertTrue(Arrays.equals(read, expected), "Bytes read not the same as written");
     }

     /**
      * Exercise Files.readAllLines(Path, Charset)
      */
     public void testReadAllLines() throws IOException {
         // zero lines
         Files.write(tmpfile, new byte[0]);
         List<String> lines = Files.readAllLines(tmpfile, US_ASCII);
             assertTrue(lines.isEmpty(), "No line expected");

         // one line
         byte[] hi = { (byte)'h', (byte)'i' };
         Files.write(tmpfile, hi);
         lines = Files.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");
         Files.write(tmpfile, expected, US_ASCII);
         assertTrue(Files.size(tmpfile) > 0, "File is empty");
         lines = Files.readAllLines(tmpfile, US_ASCII);
         assertTrue(lines.equals(expected), "Unexpected lines");

         // MalformedInputException
         byte[] bad = { (byte)0xff, (byte)0xff };
         Files.write(tmpfile, bad);
         try {
             Files.readAllLines(tmpfile, US_ASCII);
             fail("MalformedInputException expected");
         } catch (MalformedInputException ignore) { }
     }

     /**
      * Linux specific test to exercise Files.readAllLines(Path) on /proc. This
      * is special because file sizes are reported as 0 even though the file
      * has content.
      */
     public void testReadAllLinesOnProcFS() throws IOException {
         if (System.getProperty("os.name").equals("Linux")) {
             Path statFile = Paths.get("/proc/self/stat");
             List<String> lines = Files.readAllLines(statFile);
             assertTrue(lines.size() > 0, "Files.readAllLines('" + statFile + "') failed to read");
         }
     }

     /**
      * Exercise Files.readAllLines(Path)
      */
     public void testReadAllLinesUTF8() throws IOException {
         Files.write(tmpfile, encodeAsUTF8(EN_STRING + "\n" + JA_STRING));

         List<String> lines = Files.readAllLines(tmpfile);
         assertTrue(lines.size() == 2, "Read " + lines.size() + " lines instead of 2");
         assertTrue(lines.get(0).equals(EN_STRING));
         assertTrue(lines.get(1).equals(JA_STRING));

         // a sample of malformed sequences
         testReadAllLinesMalformedUTF8((byte)0xFF); // one-byte sequence
         testReadAllLinesMalformedUTF8((byte)0xC0, (byte)0x80);  // invalid first byte
         testReadAllLinesMalformedUTF8((byte)0xC2, (byte)0x00); // invalid second byte
     }

     private byte[] encodeAsUTF8(String s) throws CharacterCodingException {
         // not using s.getBytes here so as to catch unmappable characters
         ByteBuffer bb = UTF_8.newEncoder().encode(CharBuffer.wrap(s));
         byte[] result = new byte[bb.limit()];
         bb.get(result);
         assertTrue(bb.remaining() == 0);
         return result;
     }

     private void testReadAllLinesMalformedUTF8(byte... bytes) throws IOException {
         Files.write(tmpfile, bytes);
         try {
             Files.readAllLines(tmpfile);
             fail("MalformedInputException expected");
         } catch (MalformedInputException ignore) { }
     }

     /**
      * Exercise Files.write(Path, Iterable<? extends CharSequence>, Charset, OpenOption...)
      */
     public void testWriteLines() throws IOException {
         // zero lines
         Path result = Files.write(tmpfile, Collections.<String>emptyList(), US_ASCII);
         assert(Files.size(tmpfile) == 0);
         assert(result == tmpfile);

         // two lines
         List<String> lines = Arrays.asList("hi", "there");
         Files.write(tmpfile, lines, US_ASCII);
         List<String> actual = Files.readAllLines(tmpfile, US_ASCII);
         assertTrue(actual.equals(lines), "Unexpected lines");

         // append two lines
         Files.write(tmpfile, lines, US_ASCII, APPEND);
         List<String> expected = new ArrayList<>();
         expected.addAll(lines);
         expected.addAll(lines);
         assertTrue(expected.size() == 4, "List should have 4 elements");
         actual = Files.readAllLines(tmpfile, US_ASCII);
         assertTrue(actual.equals(expected), "Unexpected lines");

         // UnmappableCharacterException
         try {
             String s = "\u00A0\u00A1";
             Files.write(tmpfile, Arrays.asList(s), US_ASCII);
             fail("UnmappableCharacterException expected");
         } catch (UnmappableCharacterException ignore) { }
     }

     /**
      * Exercise Files.write(Path, Iterable<? extends CharSequence>, OpenOption...)
      */
     public void testWriteLinesUTF8() throws IOException {
         List<String> lines = Arrays.asList(EN_STRING, JA_STRING);
         Files.write(tmpfile, lines);
         List<String> actual = Files.readAllLines(tmpfile, UTF_8);
         assertTrue(actual.equals(lines), "Unexpected lines");
     }
 }
	/*
	* Copyright (c) 2011, 2013, 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 8020669 8024788 8019526
	* @build BytesAndLines PassThroughFileSystem
	* @run testng BytesAndLines
	* @summary Unit test for methods for Files readAllBytes, readAllLines and
	* and write methods.
	* @key randomness
	*/

	import java.nio.ByteBuffer;
	import java.nio.CharBuffer;
	import java.nio.file.Files;
	import java.nio.file.Path;
	import java.nio.file.Paths;
	import java.nio.file.OpenOption;
	import static java.nio.file.StandardOpenOption.*;
	import java.nio.charset.Charset;
	import java.nio.charset.CharacterCodingException;
	import java.nio.charset.MalformedInputException;
	import java.nio.charset.UnmappableCharacterException;
	import static java.nio.charset.StandardCharsets.*;
	import java.util.Arrays;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.Random;
	import java.util.concurrent.Callable;
	import java.io.IOException;

	import org.testng.annotations.AfterClass;
	import org.testng.annotations.BeforeClass;
	import org.testng.annotations.Test;
	import static org.testng.Assert.*;

	@Test(groups = "unit")
	public class BytesAndLines {

	// 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";

	// used for random byte content
	private static Random RAND = new Random();

	// file used by most tests
	private Path tmpfile;

	@BeforeClass
	void setup() throws IOException {
	tmpfile = Files.createTempFile("blah", null);
	}

	@AfterClass
	void cleanup() throws IOException {
	Files.deleteIfExists(tmpfile);
	}

	/**
	* Returns a byte[] of the given size with random content
	*/
	private byte[] genBytes(int size) {
	byte[] arr = new byte[size];
	RAND.nextBytes(arr);
	return arr;
	}

	/**
	* Exercise NullPointerException
	*/
	public void testNulls() {
	Path file = Paths.get("foo");
	byte[] bytes = new byte[100];
	List<String> lines = Collections.emptyList();

	checkNullPointerException(() -> Files.readAllBytes(null));

	checkNullPointerException(() -> Files.write(null, bytes));
	checkNullPointerException(() -> Files.write(file, (byte[])null));
	checkNullPointerException(() -> Files.write(file, bytes, (OpenOption[])null));
	checkNullPointerException(() -> Files.write(file, bytes, new OpenOption[] { null } ));

	checkNullPointerException(() -> Files.readAllLines(null));
	checkNullPointerException(() -> Files.readAllLines(file, (Charset)null));
	checkNullPointerException(() -> Files.readAllLines(null, Charset.defaultCharset()));

	checkNullPointerException(() -> Files.write(null, lines));
	checkNullPointerException(() -> Files.write(file, (List<String>)null));
	checkNullPointerException(() -> Files.write(file, lines, (OpenOption[])null));
	checkNullPointerException(() -> Files.write(file, lines, new OpenOption[] { null } ));
	checkNullPointerException(() -> Files.write(null, lines, Charset.defaultCharset()));
	checkNullPointerException(() -> Files.write(file, null, Charset.defaultCharset()));
	checkNullPointerException(() -> Files.write(file, lines, (Charset)null));
	checkNullPointerException(() -> Files.write(file, lines, Charset.defaultCharset(), (OpenOption[])null));
	checkNullPointerException(() -> Files.write(file, lines, Charset.defaultCharset(), new OpenOption[] { null } ));
	}

	private void checkNullPointerException(Callable<?> c) {
	try {
	c.call();
	fail("NullPointerException expected");
	} catch (NullPointerException ignore) {
	} catch (Exception e) {
	fail(e + " not expected");
	}
	}

	/**
	* Exercise Files.readAllBytes(Path) on varied file sizes
	*/
	public void testReadAllBytes() throws IOException {
	int size = 0;
	while (size <= 16*1024) {
	testReadAllBytes(size);
	size += 512;
	}
	}

	private void testReadAllBytes(int size) throws IOException {
	// write bytes to file (random content)
	byte[] expected = genBytes(size);
	Files.write(tmpfile, expected);

	// check expected bytes are read
	byte[] read = Files.readAllBytes(tmpfile);
	assertTrue(Arrays.equals(read, expected), "Bytes read not the same as written");
	}

	/**
	* Linux specific test to exercise Files.readAllBytes on /proc. This is
	* special because file sizes are reported as 0 even though the file
	* has content.
	*/
	public void testReadAllBytesOnProcFS() throws IOException {
	// read from procfs
	if (System.getProperty("os.name").equals("Linux")) {
	Path statFile = Paths.get("/proc/self/stat");
	byte[] data = Files.readAllBytes(statFile);
	assertTrue(data.length > 0, "Files.readAllBytes('" + statFile + "') failed to read");
	}
	}

	/**
	* Exercise Files.readAllBytes(Path) on custom file system. This is special
	* because readAllBytes was originally implemented to use FileChannel
	* and so may not be supported by custom file system providers.
	*/
	public void testReadAllBytesOnCustomFS() throws IOException {
	Path myfile = PassThroughFileSystem.create().getPath("myfile");
	try {
	int size = 0;
	while (size <= 1024) {
	byte[] b1 = genBytes(size);
	Files.write(myfile, b1);
	byte[] b2 = Files.readAllBytes(myfile);
	assertTrue(Arrays.equals(b1, b2), "bytes not equal");
	size += 512;
	}
	} finally {
	Files.deleteIfExists(myfile);
	}
	}

	/**
	* Exercise Files.write(Path, byte[], OpenOption...) on various sizes
	*/
	public void testWriteBytes() throws IOException {
	int size = 0;
	while (size < 16*1024) {
	testWriteBytes(size, false);
	testWriteBytes(size, true);
	size += 512;
	}
	}

	private void testWriteBytes(int size, boolean append) throws IOException {
	byte[] bytes = genBytes(size);
	Path result = Files.write(tmpfile, bytes);
	assertTrue(result == tmpfile);
	if (append) {
	Files.write(tmpfile, bytes, APPEND);
	assertTrue(Files.size(tmpfile) == size*2);
	}

	byte[] expected;
	if (append) {
	expected = new byte[size << 1];
	System.arraycopy(bytes, 0, expected, 0, bytes.length);
	System.arraycopy(bytes, 0, expected, bytes.length, bytes.length);
	} else {
	expected = bytes;
	}

	byte[] read = Files.readAllBytes(tmpfile);
	assertTrue(Arrays.equals(read, expected), "Bytes read not the same as written");
	}

	/**
	* Exercise Files.readAllLines(Path, Charset)
	*/
	public void testReadAllLines() throws IOException {
	// zero lines
	Files.write(tmpfile, new byte[0]);
	List<String> lines = Files.readAllLines(tmpfile, US_ASCII);
	assertTrue(lines.isEmpty(), "No line expected");

	// one line
	byte[] hi = { (byte)'h', (byte)'i' };
	Files.write(tmpfile, hi);
	lines = Files.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");
	Files.write(tmpfile, expected, US_ASCII);
	assertTrue(Files.size(tmpfile) > 0, "File is empty");
	lines = Files.readAllLines(tmpfile, US_ASCII);
	assertTrue(lines.equals(expected), "Unexpected lines");

	// MalformedInputException
	byte[] bad = { (byte)0xff, (byte)0xff };
	Files.write(tmpfile, bad);
	try {
	Files.readAllLines(tmpfile, US_ASCII);
	fail("MalformedInputException expected");
	} catch (MalformedInputException ignore) { }
	}

	/**
	* Linux specific test to exercise Files.readAllLines(Path) on /proc. This
	* is special because file sizes are reported as 0 even though the file
	* has content.
	*/
	public void testReadAllLinesOnProcFS() throws IOException {
	if (System.getProperty("os.name").equals("Linux")) {
	Path statFile = Paths.get("/proc/self/stat");
	List<String> lines = Files.readAllLines(statFile);
	assertTrue(lines.size() > 0, "Files.readAllLines('" + statFile + "') failed to read");
	}
	}

	/**
	* Exercise Files.readAllLines(Path)
	*/
	public void testReadAllLinesUTF8() throws IOException {
	Files.write(tmpfile, encodeAsUTF8(EN_STRING + "\n" + JA_STRING));

	List<String> lines = Files.readAllLines(tmpfile);
	assertTrue(lines.size() == 2, "Read " + lines.size() + " lines instead of 2");
	assertTrue(lines.get(0).equals(EN_STRING));
	assertTrue(lines.get(1).equals(JA_STRING));

	// a sample of malformed sequences
	testReadAllLinesMalformedUTF8((byte)0xFF); // one-byte sequence
	testReadAllLinesMalformedUTF8((byte)0xC0, (byte)0x80); // invalid first byte
	testReadAllLinesMalformedUTF8((byte)0xC2, (byte)0x00); // invalid second byte
	}

	private byte[] encodeAsUTF8(String s) throws CharacterCodingException {
	// not using s.getBytes here so as to catch unmappable characters
	ByteBuffer bb = UTF_8.newEncoder().encode(CharBuffer.wrap(s));
	byte[] result = new byte[bb.limit()];
	bb.get(result);
	assertTrue(bb.remaining() == 0);
	return result;
	}

	private void testReadAllLinesMalformedUTF8(byte... bytes) throws IOException {
	Files.write(tmpfile, bytes);
	try {
	Files.readAllLines(tmpfile);
	fail("MalformedInputException expected");
	} catch (MalformedInputException ignore) { }
	}

	/**
	* Exercise Files.write(Path, Iterable<? extends CharSequence>, Charset, OpenOption...)
	*/
	public void testWriteLines() throws IOException {
	// zero lines
	Path result = Files.write(tmpfile, Collections.<String>emptyList(), US_ASCII);
	assert(Files.size(tmpfile) == 0);
	assert(result == tmpfile);

	// two lines
	List<String> lines = Arrays.asList("hi", "there");
	Files.write(tmpfile, lines, US_ASCII);
	List<String> actual = Files.readAllLines(tmpfile, US_ASCII);
	assertTrue(actual.equals(lines), "Unexpected lines");

	// append two lines
	Files.write(tmpfile, lines, US_ASCII, APPEND);
	List<String> expected = new ArrayList<>();
	expected.addAll(lines);
	expected.addAll(lines);
	assertTrue(expected.size() == 4, "List should have 4 elements");
	actual = Files.readAllLines(tmpfile, US_ASCII);
	assertTrue(actual.equals(expected), "Unexpected lines");

	// UnmappableCharacterException
	try {
	String s = "\u00A0\u00A1";
	Files.write(tmpfile, Arrays.asList(s), US_ASCII);
	fail("UnmappableCharacterException expected");
	} catch (UnmappableCharacterException ignore) { }
	}

	/**
	* Exercise Files.write(Path, Iterable<? extends CharSequence>, OpenOption...)
	*/
	public void testWriteLinesUTF8() throws IOException {
	List<String> lines = Arrays.asList(EN_STRING, JA_STRING);
	Files.write(tmpfile, lines);
	List<String> actual = Files.readAllLines(tmpfile, UTF_8);
	assertTrue(actual.equals(lines), "Unexpected lines");
	}
	}