/* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package libcore.java.nio.channels;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.DatagramChannel;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.channels.NonWritableChannelException;
import java.nio.channels.OverlappingFileLockException;
import java.nio.channels.ReadableByteChannel;
import java.nio.channels.WritableByteChannel;
import java.util.Arrays;
import junit.framework.TestCase;
public final class OldFileChannelTest extends TestCase {
private static final int CAPACITY = 100;
private static final String CONTENT = "MYTESTSTRING needs to be a little long";
private static final byte[] TEST_BYTES;
static {
try {
TEST_BYTES = "test".getBytes("iso8859-1");
} catch (UnsupportedEncodingException e) {
throw new Error(e);
}
}
private static final int CONTENT_LENGTH = CONTENT.length();
private static final byte[] CONTENT_AS_BYTES = CONTENT.getBytes();
private static final int CONTENT_AS_BYTES_LENGTH = CONTENT_AS_BYTES.length;
private FileChannel readOnlyFileChannel;
private FileChannel writeOnlyFileChannel;
private FileChannel readWriteFileChannel;
private File fileOfReadOnlyFileChannel;
private File fileOfWriteOnlyFileChannel;
private File fileOfReadWriteFileChannel;
// to read content from FileChannel
private FileInputStream fis;
private FileLock fileLock;
protected void setUp() throws Exception {
fileOfReadOnlyFileChannel = File.createTempFile(
"File_of_readOnlyFileChannel", "tmp");
fileOfReadOnlyFileChannel.deleteOnExit();
fileOfWriteOnlyFileChannel = File.createTempFile(
"File_of_writeOnlyFileChannel", "tmp");
fileOfWriteOnlyFileChannel.deleteOnExit();
fileOfReadWriteFileChannel = File.createTempFile(
"File_of_readWriteFileChannel", "tmp");
fileOfReadWriteFileChannel.deleteOnExit();
fis = null;
fileLock = null;
readOnlyFileChannel = new FileInputStream(fileOfReadOnlyFileChannel)
.getChannel();
writeOnlyFileChannel = new FileOutputStream(fileOfWriteOnlyFileChannel)
.getChannel();
readWriteFileChannel = new RandomAccessFile(fileOfReadWriteFileChannel,
"rw").getChannel();
}
protected void tearDown() {
if (null != readOnlyFileChannel) {
try {
readOnlyFileChannel.close();
} catch (IOException e) {
// do nothing
}
}
if (null != writeOnlyFileChannel) {
try {
writeOnlyFileChannel.close();
} catch (IOException e) {
// do nothing
}
}
if (null != readWriteFileChannel) {
try {
readWriteFileChannel.close();
} catch (IOException e) {
// do nothing
}
}
if (null != fis) {
try {
fis.close();
} catch (IOException e) {
// do nothing
}
}
if (null != fileLock) {
try {
fileLock.release();
} catch (IOException e) {
// do nothing
}
}
if (null != fileOfReadOnlyFileChannel) {
fileOfReadOnlyFileChannel.delete();
}
if (null != fileOfWriteOnlyFileChannel) {
fileOfWriteOnlyFileChannel.delete();
}
if (null != fileOfReadWriteFileChannel) {
fileOfReadWriteFileChannel.delete();
}
}
public void test_forceZ() throws Exception {
ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
writeOnlyFileChannel.write(writeBuffer);
writeOnlyFileChannel.force(true);
byte[] readBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
fis = new FileInputStream(fileOfWriteOnlyFileChannel);
fis.read(readBuffer);
assertTrue(Arrays.equals(CONTENT_AS_BYTES, readBuffer));
writeOnlyFileChannel.write(writeBuffer);
writeOnlyFileChannel.force(false);
fis.close();
readBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
fis = new FileInputStream(fileOfWriteOnlyFileChannel);
fis.read(readBuffer);
assertTrue(Arrays.equals(CONTENT_AS_BYTES, readBuffer));
fis.close();
}
/**
* Initializes test file.
*
* @param file
* @throws FileNotFoundException
* @throws IOException
*/
private void writeDataToFile(File file) throws FileNotFoundException,
IOException {
FileOutputStream fos = new FileOutputStream(file);
try {
fos.write(CONTENT_AS_BYTES);
} finally {
fos.close();
}
}
/**
* Initializes large test file.
*
* @param file the file to be written
* @param size the content size to be written
* @throws FileNotFoundException
* @throws IOException
*/
private void writeLargeDataToFile(File file, int size)
throws FileNotFoundException, IOException {
FileOutputStream fos = new FileOutputStream(file);
byte[] buf = new byte[size];
try {
// we don't care about content - just need a particular file size
fos.write(buf);
} finally {
fos.close();
}
}
public void test_tryLockJJZ_IllegalArgument() throws Exception {
try {
writeOnlyFileChannel.tryLock(0, -1, false);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
try {
writeOnlyFileChannel.tryLock(-1, 0, false);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
try {
readWriteFileChannel.tryLock(-1, -1, false);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
try {
readWriteFileChannel.tryLock(Long.MAX_VALUE, 1, false);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
}
public void testTryLockVeryLarge() throws IOException {
long tooBig = Integer.MAX_VALUE + 1L;
FileLock lock = readWriteFileChannel.tryLock(tooBig, 1, false);
assertLockFails(tooBig, 1);
lock.release();
lock = readWriteFileChannel.tryLock(0, tooBig, false);
assertLockFails(0, 1);
lock.release();
}
public void testTryLockOverlapping() throws IOException {
FileLock lockOne = readWriteFileChannel.tryLock(0, 10, false);
FileLock lockTwo = readWriteFileChannel.tryLock(10, 20, false);
assertLockFails(0, 10);
lockOne.release();
assertLockFails(5, 10);
lockOne = readWriteFileChannel.tryLock(0, 10, false);
lockTwo.release();
lockOne.release();
}
public void test_readLByteBufferJ_IllegalArgument() throws Exception {
ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
try {
readOnlyFileChannel.read(readBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
try {
writeOnlyFileChannel.read(readBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
try {
readWriteFileChannel.read(readBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
// throws IllegalArgumentException first.
readOnlyFileChannel.close();
try {
readOnlyFileChannel.read(readBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
writeOnlyFileChannel.close();
try {
writeOnlyFileChannel.read(readBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
readWriteFileChannel.close();
try {
readWriteFileChannel.read(readBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
}
public void test_read$LByteBufferII_Null() throws Exception {
try {
readOnlyFileChannel.read(null, 0, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 0, 3);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 2, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 3, 0);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 0, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 0, 3);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 2, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 3, 0);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 0, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 0, 3);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 2, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 3, 0);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
// first throws NullPointerException
readOnlyFileChannel.close();
try {
readOnlyFileChannel.read(null, 0, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 0, 3);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 2, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readOnlyFileChannel.read(null, 3, 0);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
readWriteFileChannel.close();
try {
readWriteFileChannel.read(null, 0, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 0, 3);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 2, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.read(null, 3, 0);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
writeOnlyFileChannel.close();
try {
writeOnlyFileChannel.read(null, 0, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 0, 3);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 2, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.read(null, 3, 0);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
private void doTestForIOOBException(FileChannel channel,
ByteBuffer[] buffer) throws IOException{
try {
channel.read(buffer, -1, 0);
fail("should throw IndexOutOfBoundException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
channel.read(buffer, 0, -1);
fail("should throw IndexOutOfBoundException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
channel.read(buffer, 0, 3);
fail("should throw IndexOutOfBoundException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
channel.read(buffer, 1, 2);
fail("should throw IndexOutOfBoundException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
channel.read(buffer, 2, 1);
fail("should throw IndexOutOfBoundException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
channel.read(buffer, 3, 0);
fail("should throw IndexOutOfBoundException");
} catch (IndexOutOfBoundsException e) {
// expected
}
}
public void test_read$LByteBufferII_IndexOutOfBound() throws Exception {
ByteBuffer[] readBuffers = new ByteBuffer[2];
readBuffers[0] = ByteBuffer.allocate(CAPACITY);
readBuffers[1] = ByteBuffer.allocate(CAPACITY);
ByteBuffer[] readBuffersNull = new ByteBuffer[2];
doTestForIOOBException(readOnlyFileChannel, readBuffers);
doTestForIOOBException(readWriteFileChannel, readBuffers);
doTestForIOOBException(writeOnlyFileChannel, readBuffers);
doTestForIOOBException(readOnlyFileChannel, readBuffersNull);
doTestForIOOBException(readWriteFileChannel, readBuffersNull);
doTestForIOOBException(writeOnlyFileChannel, readBuffersNull);
try {
readOnlyFileChannel.read(null, -1, 0);
fail("should throw IndexOutOfBoundException");
} catch (NullPointerException expected) {
} catch (IndexOutOfBoundsException expected) {
}
try {
readOnlyFileChannel.read(null, 0, -1);
fail("should throw IndexOutOfBoundException");
} catch (NullPointerException expected) {
} catch (IndexOutOfBoundsException expected) {
}
try {
readWriteFileChannel.read(null, -1, 0);
fail("should throw IndexOutOfBoundException");
} catch (NullPointerException expected) {
} catch (IndexOutOfBoundsException expected) {
}
try {
readWriteFileChannel.read(null, 0, -1);
fail("should throw IndexOutOfBoundException");
} catch (NullPointerException expected) {
} catch (IndexOutOfBoundsException expected) {
}
try {
writeOnlyFileChannel.read(null, -1, 0);
fail("should throw IndexOutOfBoundException");
} catch (NullPointerException expected) {
} catch (IndexOutOfBoundsException expected) {
}
try {
writeOnlyFileChannel.read(null, 0, -1);
fail("should throw IndexOutOfBoundException");
} catch (NullPointerException expected) {
} catch (IndexOutOfBoundsException expected) {
}
readOnlyFileChannel.close();
doTestForIOOBException(readOnlyFileChannel, readBuffers);
doTestForIOOBException(readOnlyFileChannel, readBuffersNull);
readWriteFileChannel.close();
doTestForIOOBException(readWriteFileChannel, readBuffers);
doTestForIOOBException(readWriteFileChannel, readBuffersNull);
writeOnlyFileChannel.close();
doTestForIOOBException(writeOnlyFileChannel, readBuffers);
doTestForIOOBException(writeOnlyFileChannel, readBuffersNull);
}
public void test_read$LByteBufferII_EmptyFile() throws Exception {
ByteBuffer[] readBuffers = new ByteBuffer[2];
readBuffers[0] = ByteBuffer.allocate(CAPACITY);
readBuffers[1] = ByteBuffer.allocate(CAPACITY);
long result = readOnlyFileChannel.read(readBuffers, 0, 2);
assertEquals(-1, result);
assertEquals(0, readBuffers[0].position());
assertEquals(0, readBuffers[1].position());
}
public void test_read$LByteBufferII_EmptyBuffers() throws Exception {
ByteBuffer[] readBuffers = new ByteBuffer[2];
readBuffers[0] = ByteBuffer.allocate(CAPACITY);
try {
readOnlyFileChannel.read(readBuffers, 0, 2);
} catch (NullPointerException e) {
// expected
}
writeDataToFile(fileOfReadOnlyFileChannel);
readBuffers[0] = ByteBuffer.allocate(CAPACITY);
try {
readOnlyFileChannel.read(readBuffers, 0, 2);
} catch (NullPointerException e) {
// expected
}
long result = readOnlyFileChannel.read(readBuffers, 0, 1);
assertEquals(CONTENT_AS_BYTES_LENGTH, result);
}
public void test_isOpen() throws Exception {
// Regression for HARMONY-40
File logFile = File.createTempFile("out", "tmp");
logFile.deleteOnExit();
FileOutputStream out = new FileOutputStream(logFile, true);
FileChannel channel = out.getChannel();
out.write(1);
assertTrue("Assert 0: Channel is not open", channel.isOpen());
out.close();
assertFalse("Assert 0: Channel is still open", channel.isOpen());
}
public void test_writeLByteBuffer_Closed() throws Exception {
ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
readOnlyFileChannel.close();
try {
readOnlyFileChannel.write(writeBuffer);
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
writeOnlyFileChannel.close();
try {
writeOnlyFileChannel.write(writeBuffer);
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
readWriteFileChannel.close();
try {
readWriteFileChannel.write(writeBuffer);
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
// should throw ClosedChannelException first
try {
readWriteFileChannel.read((ByteBuffer) null);
fail("should throw ClosedChannelException");
} catch (NullPointerException e) {
} catch (ClosedChannelException e) {
}
try {
readOnlyFileChannel.write((ByteBuffer) null);
fail("should throw ClosedChannelException");
} catch (NullPointerException e) {
} catch (ClosedChannelException e) {
}
writeOnlyFileChannel.close();
try {
writeOnlyFileChannel.write((ByteBuffer) null);
fail("should throw ClosedChannelException");
} catch (NullPointerException e) {
} catch (ClosedChannelException e) {
}
}
public void test_writeLByteBufferJ_Postion_As_Long() throws Exception {
ByteBuffer writeBuffer = ByteBuffer.wrap(TEST_BYTES);
try {
writeOnlyFileChannel.write(writeBuffer, Long.MAX_VALUE);
} catch (IOException e) {
// expected
}
}
public void test_writeLByteBufferJ_IllegalArgument() throws Exception {
ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
try {
readOnlyFileChannel.write(writeBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
try {
writeOnlyFileChannel.write(writeBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
// throws IllegalArgumentException first.
readOnlyFileChannel.close();
try {
readOnlyFileChannel.write(writeBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
writeOnlyFileChannel.close();
try {
writeOnlyFileChannel.write(writeBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
readWriteFileChannel.close();
try {
readWriteFileChannel.write(writeBuffer, -1);
fail("should throw IllegalArgumentException");
} catch (IllegalArgumentException e) {
// expected
}
}
public void test_writeLByteBufferJ_NonZeroPosition() throws Exception {
final int pos = 5;
ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
writeBuffer.position(pos);
int result = writeOnlyFileChannel.write(writeBuffer, pos);
assertEquals(CONTENT_AS_BYTES_LENGTH - pos, result);
assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffer.position());
writeOnlyFileChannel.close();
assertEquals(CONTENT_AS_BYTES_LENGTH, fileOfWriteOnlyFileChannel
.length());
fis = new FileInputStream(fileOfWriteOnlyFileChannel);
byte[] inputBuffer = new byte[CONTENT_AS_BYTES_LENGTH - pos];
fis.skip(pos);
fis.read(inputBuffer);
String test = CONTENT.substring(pos);
assertTrue(Arrays.equals(test.getBytes(), inputBuffer));
}
public void test_write$LByteBuffer_Closed() throws Exception {
ByteBuffer[] writeBuffers = new ByteBuffer[2];
writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
writeBuffers[1] = ByteBuffer.allocate(CAPACITY);
readOnlyFileChannel.close();
try {
readOnlyFileChannel.write(writeBuffers);
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
writeOnlyFileChannel.close();
try {
writeOnlyFileChannel.write(writeBuffers);
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
readWriteFileChannel.close();
try {
readWriteFileChannel.write(writeBuffers);
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
}
public void test_write$LByteBuffer_ReadOnly() throws Exception {
ByteBuffer[] writeBuffers = new ByteBuffer[2];
writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
writeBuffers[1] = ByteBuffer.allocate(CAPACITY);
try {
readOnlyFileChannel.write(writeBuffers);
fail("should throw NonWritableChannelException");
} catch (NonWritableChannelException e) {
// expected
}
}
public void test_write$LByteBuffer_EmptyBuffers() throws Exception {
ByteBuffer[] writeBuffers = new ByteBuffer[2];
writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
try {
writeOnlyFileChannel.write(writeBuffers);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
public void test_write$LByteBuffer() throws Exception {
ByteBuffer[] writeBuffers = new ByteBuffer[2];
writeBuffers[0] = ByteBuffer.wrap(CONTENT_AS_BYTES);
writeBuffers[1] = ByteBuffer.wrap(CONTENT_AS_BYTES);
long result = writeOnlyFileChannel.write(writeBuffers);
assertEquals(CONTENT_AS_BYTES_LENGTH * 2, result);
assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffers[0].position());
assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffers[1].position());
writeOnlyFileChannel.close();
assertEquals(CONTENT_AS_BYTES_LENGTH * 2, fileOfWriteOnlyFileChannel
.length());
fis = new FileInputStream(fileOfWriteOnlyFileChannel);
byte[] inputBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
fis.read(inputBuffer);
byte[] expectedResult = new byte[CONTENT_AS_BYTES_LENGTH * 2];
System.arraycopy(CONTENT_AS_BYTES, 0, expectedResult, 0,
CONTENT_AS_BYTES_LENGTH);
System.arraycopy(CONTENT_AS_BYTES, 0, expectedResult,
CONTENT_AS_BYTES_LENGTH, CONTENT_AS_BYTES_LENGTH);
assertTrue(Arrays.equals(CONTENT_AS_BYTES, inputBuffer));
}
public void test_write$LByteBufferII_Null() throws Exception {
ByteBuffer[] writeBuffers = null;
try {
readOnlyFileChannel.write(writeBuffers, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
writeOnlyFileChannel.write(writeBuffers, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
// first throws NullPointerException
readOnlyFileChannel.close();
try {
readOnlyFileChannel.write(writeBuffers, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
writeOnlyFileChannel.close();
try {
writeOnlyFileChannel.write(writeBuffers, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
readWriteFileChannel.close();
try {
readWriteFileChannel.write(writeBuffers, 1, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
public void test_write$LByteBufferII_IndexOutOfBound() throws Exception {
ByteBuffer[] writeBuffers = new ByteBuffer[2];
writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
writeBuffers[1] = ByteBuffer.allocate(this.CONTENT_LENGTH);
try {
writeOnlyFileChannel.write(writeBuffers, -1, 0);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
writeOnlyFileChannel.write(writeBuffers, 0, -1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
writeOnlyFileChannel.write(writeBuffers, 0, 3);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
writeOnlyFileChannel.write(writeBuffers, 1, 2);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
writeOnlyFileChannel.write(writeBuffers, 2, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
writeOnlyFileChannel.write(writeBuffers, 3, 0);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, -1, 0);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, 0, -1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, 0, 3);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, 1, 2);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, 2, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, 3, 0);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readOnlyFileChannel.write(writeBuffers, -1, 0);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readOnlyFileChannel.write(writeBuffers, 0, -1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readOnlyFileChannel.write(writeBuffers, 0, 3);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readOnlyFileChannel.write(writeBuffers, 1, 2);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readOnlyFileChannel.write(writeBuffers, 2, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
try {
readOnlyFileChannel.write(writeBuffers, 3, 0);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
}
public void test_write$LByteBufferII_EmptyBuffers() throws Exception {
ByteBuffer[] writeBuffers = new ByteBuffer[2];
writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
try {
writeOnlyFileChannel.write(writeBuffers, 0, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
readWriteFileChannel.write(writeBuffers, 0, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
}
public void test_transferToJJLWritableByteChannel_IllegalArgument()
throws Exception {
WritableByteChannel writableByteChannel = DatagramChannel.open();
try {
readOnlyFileChannel.transferTo(10, -1, writableByteChannel);
fail("should throw IllegalArgumentException.");
} catch (IllegalArgumentException e) {
// expected
}
try {
readWriteFileChannel.transferTo(-1, 10, writableByteChannel);
fail("should throw IllegalArgumentException.");
} catch (IllegalArgumentException e) {
// expected
}
}
private void assertLockFails(long position, long size) throws IOException {
try {
readWriteFileChannel.tryLock(position, size, false);
fail();
} catch (OverlappingFileLockException expected) {
}
}
}