Quelle  BytesAndLines.java   Sprache: JAVA

/*
 * 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");
    }
}