--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/jdk/java/nio/channels/FileChannel/MapTest.java Tue Sep 12 19:03:39 2017 +0200
@@ -0,0 +1,307 @@
+/*
+ * Copyright (c) 2000, 2012, 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 4429043 8002180
+ * @summary Test file mapping with FileChannel
+ * @run main/othervm MapTest
+ * @key randomness
+ */
+
+import java.io.*;
+import java.nio.MappedByteBuffer;
+import java.nio.channels.*;
+import java.nio.channels.FileChannel.MapMode;
+import java.nio.file.Files;
+import static java.nio.file.StandardOpenOption.*;
+import static java.nio.charset.StandardCharsets.*;
+import java.util.Random;
+
+
+/**
+ * Testing FileChannel's mapping capabilities.
+ */
+
+public class MapTest {
+
+ private static PrintStream out = System.out;
+ private static PrintStream err = System.err;
+
+ private static Random generator = new Random();
+
+ private static int CHARS_PER_LINE = File.separatorChar == '/' ? 5 : 6;
+
+ private static File blah;
+
+ public static void main(String[] args) throws Exception {
+ blah = File.createTempFile("blah", null);
+ blah.deleteOnExit();
+ initTestFile(blah);
+ try {
+ out.println("Test file " + blah + " initialized");
+ testZero();
+ out.println("Zero size: OK");
+ testRead();
+ out.println("Read: OK");
+ testWrite();
+ out.println("Write: OK");
+ testHighOffset();
+ out.println("High offset: OK");
+ testExceptions();
+ out.println("Exceptions: OK");
+ } finally {
+ blah.delete();
+ }
+ }
+
+ /**
+ * Creates file blah:
+ * 0000
+ * 0001
+ * 0002
+ * 0003
+ * .
+ * .
+ * .
+ * 3999
+ *
+ * Blah extends beyond a single page of memory so that the
+ * ability to index into a file of multiple pages is tested.
+ */
+ private static void initTestFile(File blah) throws Exception {
+ try (BufferedWriter writer = Files.newBufferedWriter(blah.toPath(), ISO_8859_1)) {
+ for (int i=0; i<4000; i++) {
+ String number = new Integer(i).toString();
+ for (int h=0; h<4-number.length(); h++)
+ writer.write("0");
+ writer.write(""+i);
+ writer.newLine();
+ }
+ }
+ }
+
+ /**
+ * Tests zero size file mapping
+ */
+ private static void testZero() throws Exception {
+ try (FileInputStream fis = new FileInputStream(blah)) {
+ FileChannel fc = fis.getChannel();
+ MappedByteBuffer b = fc.map(MapMode.READ_ONLY, 0, 0);
+ }
+ }
+
+ /**
+ * Maps blah file with a random offset and checks to see if read
+ * from the ByteBuffer gets the right line number
+ */
+ private static void testRead() throws Exception {
+ StringBuilder sb = new StringBuilder();
+ sb.setLength(4);
+
+ for (int x=0; x<1000; x++) {
+ try (FileInputStream fis = new FileInputStream(blah)) {
+ FileChannel fc = fis.getChannel();
+
+ long offset = generator.nextInt(10000);
+ long expectedResult = offset / CHARS_PER_LINE;
+ offset = expectedResult * CHARS_PER_LINE;
+
+ MappedByteBuffer b = fc.map(MapMode.READ_ONLY,
+ offset, 100);
+
+ for (int i=0; i<4; i++) {
+ byte aByte = b.get(i);
+ sb.setCharAt(i, (char)aByte);
+ }
+
+ int result = Integer.parseInt(sb.toString());
+ if (result != expectedResult) {
+ err.println("I expected "+expectedResult);
+ err.println("I got "+result);
+ throw new Exception("Read test failed");
+ }
+ }
+ }
+ }
+
+ /**
+ * Maps blah file with a random offset and checks to see if data
+ * written out to the file can be read back in
+ */
+ private static void testWrite() throws Exception {
+ StringBuilder sb = new StringBuilder();
+ sb.setLength(4);
+
+ for (int x=0; x<1000; x++) {
+ try (RandomAccessFile raf = new RandomAccessFile(blah, "rw")) {
+ FileChannel fc = raf.getChannel();
+
+ long offset = generator.nextInt(1000);
+ MappedByteBuffer b = fc.map(MapMode.READ_WRITE,
+ offset, 100);
+
+ for (int i=0; i<4; i++) {
+ b.put(i, (byte)('0' + i));
+ }
+
+ for (int i=0; i<4; i++) {
+ byte aByte = b.get(i);
+ sb.setCharAt(i, (char)aByte);
+ }
+ if (!sb.toString().equals("0123"))
+ throw new Exception("Write test failed");
+ }
+ }
+ }
+
+ private static void testHighOffset() throws Exception {
+ StringBuilder sb = new StringBuilder();
+ sb.setLength(4);
+
+ for (int x=0; x<1000; x++) {
+ try (RandomAccessFile raf = new RandomAccessFile(blah, "rw")) {
+ FileChannel fc = raf.getChannel();
+ long offset = 66000;
+ MappedByteBuffer b = fc.map(MapMode.READ_WRITE,
+ offset, 100);
+ }
+ }
+ }
+
+ /**
+ * Test exceptions specified by map method
+ */
+ private static void testExceptions() throws Exception {
+ // check exceptions when channel opened for read access
+ try (FileChannel fc = FileChannel.open(blah.toPath(), READ)) {
+ testExceptions(fc);
+
+ checkException(fc, MapMode.READ_WRITE, 0L, fc.size(),
+ NonWritableChannelException.class);
+
+ checkException(fc, MapMode.READ_WRITE, -1L, fc.size(),
+ NonWritableChannelException.class, IllegalArgumentException.class);
+
+ checkException(fc, MapMode.READ_WRITE, 0L, -1L,
+ NonWritableChannelException.class, IllegalArgumentException.class);
+
+ checkException(fc, MapMode.PRIVATE, 0L, fc.size(),
+ NonWritableChannelException.class);
+
+ checkException(fc, MapMode.PRIVATE, -1L, fc.size(),
+ NonWritableChannelException.class, IllegalArgumentException.class);
+
+ checkException(fc, MapMode.PRIVATE, 0L, -1L,
+ NonWritableChannelException.class, IllegalArgumentException.class);
+ }
+
+ // check exceptions when channel opened for write access
+ try (FileChannel fc = FileChannel.open(blah.toPath(), WRITE)) {
+ testExceptions(fc);
+
+ checkException(fc, MapMode.READ_ONLY, 0L, fc.size(),
+ NonReadableChannelException.class);
+
+ checkException(fc, MapMode.READ_ONLY, -1L, fc.size(),
+ NonReadableChannelException.class, IllegalArgumentException.class);
+
+ /*
+ * implementation/spec mismatch, these tests disabled for now
+ */
+ //checkException(fc, MapMode.READ_WRITE, 0L, fc.size(),
+ // NonWritableChannelException.class);
+ //checkException(fc, MapMode.PRIVATE, 0L, fc.size(),
+ // NonWritableChannelException.class);
+ }
+
+ // check exceptions when channel opened for read and write access
+ try (FileChannel fc = FileChannel.open(blah.toPath(), READ, WRITE)) {
+ testExceptions(fc);
+ }
+ }
+
+ private static void testExceptions(FileChannel fc) throws IOException {
+ checkException(fc, null, 0L, fc.size(),
+ NullPointerException.class);
+
+ checkException(fc, MapMode.READ_ONLY, -1L, fc.size(),
+ IllegalArgumentException.class);
+
+ checkException(fc, null, -1L, fc.size(),
+ IllegalArgumentException.class, NullPointerException.class);
+
+ checkException(fc, MapMode.READ_ONLY, 0L, -1L,
+ IllegalArgumentException.class);
+
+ checkException(fc, null, 0L, -1L,
+ IllegalArgumentException.class, NullPointerException.class);
+
+ checkException(fc, MapMode.READ_ONLY, 0L, Integer.MAX_VALUE + 1L,
+ IllegalArgumentException.class);
+
+ checkException(fc, null, 0L, Integer.MAX_VALUE + 1L,
+ IllegalArgumentException.class, NullPointerException.class);
+
+ checkException(fc, MapMode.READ_ONLY, Long.MAX_VALUE, 1L,
+ IllegalArgumentException.class);
+
+ checkException(fc, null, Long.MAX_VALUE, 1L,
+ IllegalArgumentException.class, NullPointerException.class);
+
+ }
+
+ /**
+ * Checks that FileChannel map throws one of the expected exceptions
+ * when invoked with the given inputs.
+ */
+ private static void checkException(FileChannel fc,
+ MapMode mode,
+ long position,
+ long size,
+ Class<?>... expected)
+ throws IOException
+ {
+ Exception exc = null;
+ try {
+ fc.map(mode, position, size);
+ } catch (Exception actual) {
+ exc = actual;
+ }
+ if (exc != null) {
+ for (Class<?> clazz: expected) {
+ if (clazz.isInstance(exc)) {
+ return;
+ }
+ }
+ }
+ System.err.println("Expected one of");
+ for (Class<?> clazz: expected) {
+ System.out.println(clazz);
+ }
+ if (exc == null) {
+ throw new RuntimeException("No expection thrown");
+ } else {
+ throw new RuntimeException("Unexpected exception thrown", exc);
+ }
+ }
+}