test/jdk/java/nio/channels/FileChannel/MapTest.java - platform/libcore - Git at Google

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