| /* 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 org.apache.harmony.nio.tests.java.nio.channels; |
| |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargets; |
| |
| import java.io.IOException; |
| import java.nio.ByteBuffer; |
| import java.nio.channels.AsynchronousCloseException; |
| import java.nio.channels.ClosedByInterruptException; |
| import java.nio.channels.ClosedChannelException; |
| import java.nio.channels.Pipe; |
| import java.nio.channels.SelectionKey; |
| import java.nio.channels.Pipe.SourceChannel; |
| import java.nio.channels.spi.SelectorProvider; |
| |
| import junit.framework.TestCase; |
| @TestTargetClass( |
| value = java.nio.channels.Pipe.SourceChannel.class, |
| untestedMethods = { |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "AsynchronousCloseException can not easily be tested", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| } |
| ) |
| /** |
| * Tests for java.nio.channels.Pipe.SourceChannel |
| */ |
| public class SourceChannelTest extends TestCase { |
| |
| private static final int BUFFER_SIZE = 5; |
| |
| private static final String ISO8859_1 = "ISO8859-1"; |
| |
| private Pipe pipe; |
| |
| private Pipe.SinkChannel sink; |
| |
| private Pipe.SourceChannel source; |
| |
| private ByteBuffer buffer; |
| |
| private ByteBuffer positionedBuffer; |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| pipe = Pipe.open(); |
| sink = pipe.sink(); |
| source = pipe.source(); |
| buffer = ByteBuffer.wrap("bytes".getBytes(ISO8859_1)); |
| positionedBuffer = ByteBuffer.wrap("12345bytes".getBytes(ISO8859_1)); |
| positionedBuffer.position(BUFFER_SIZE); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#validOps() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "validOps", |
| args = {} |
| ) |
| public void test_validOps() { |
| assertEquals(SelectionKey.OP_READ, source.validOps()); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_LByteBuffer_DataAvailable() throws IOException { |
| // if anything can read, read method will not block |
| sink.write(ByteBuffer.allocate(1)); |
| int count = source.read(ByteBuffer.allocate(10)); |
| assertEquals(1, count); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException.", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_LByteBuffer_Exception() throws IOException { |
| ByteBuffer nullBuf = null; |
| try { |
| source.read(nullBuf); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_LByteBuffer_SinkClosed() throws IOException { |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| sink.write(buffer); |
| sink.close(); |
| long count = source.read(readBuf); |
| assertEquals(BUFFER_SIZE, count); |
| // readBuf is full, read 0 byte expected |
| count = source.read(readBuf); |
| assertEquals(0, count); |
| // readBuf is not null, -1 is expected |
| readBuf.position(0); |
| count = source.read(readBuf); |
| assertEquals(-1, count); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies ClosedChannelException, NullPointerException.", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_LByteBuffer_SourceClosed() throws IOException { |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| source.close(); |
| try { |
| source.read(readBuf); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| readBuf.position(BUFFER_SIZE); |
| try { |
| // readBuf is full |
| source.read(readBuf); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| |
| ByteBuffer nullBuf = null; |
| try { |
| source.read(nullBuf); |
| fail("should throw NullPointerException"); |
| } catch (ClosedChannelException e) { |
| // expected on RI |
| } catch (NullPointerException e) { |
| // expected on Harmony/Android |
| } |
| |
| ByteBuffer[] bufArray = null; |
| try { |
| source.read(bufArray); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| ByteBuffer[] nullBufArray = {nullBuf}; |
| try { |
| source.read(nullBufArray); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_$LByteBuffer() throws IOException { |
| ByteBuffer[] bufArray = { buffer, positionedBuffer }; |
| boolean[] sinkBlockingMode = { true, true, false, false }; |
| boolean[] sourceBlockingMode = { true, false, true, false }; |
| for (int i = 0; i < sinkBlockingMode.length; ++i) { |
| // open new pipe everytime, will be closed in finally block |
| pipe = Pipe.open(); |
| sink = pipe.sink(); |
| source = pipe.source(); |
| sink.configureBlocking(sinkBlockingMode[i]); |
| source.configureBlocking(sourceBlockingMode[i]); |
| buffer.position(0); |
| positionedBuffer.position(BUFFER_SIZE); |
| try { |
| long writeCount = sink.write(bufArray); |
| assertEquals(10, writeCount); |
| // invoke close to ensure all data will be sent out |
| sink.close(); |
| // read until EOF is meet or readBufArray is full. |
| ByteBuffer[] readBufArray = { ByteBuffer.allocate(BUFFER_SIZE), |
| ByteBuffer.allocate(BUFFER_SIZE) }; |
| long totalCount = 0; |
| do { |
| long count = source.read(readBufArray); |
| if (count < 0) { |
| break; |
| } |
| if (0 == count && BUFFER_SIZE == readBufArray[1].position()) { |
| // source.read returns 0 because readBufArray is full |
| break; |
| } |
| totalCount += count; |
| } while (totalCount <= 10); |
| // assert read result |
| for (ByteBuffer readBuf : readBufArray) { |
| // RI may fail because of its bug implementation |
| assertEquals(BUFFER_SIZE, readBuf.position()); |
| assertEquals("bytes", |
| new String(readBuf.array(), ISO8859_1)); |
| } |
| } finally { |
| // close pipe everytime |
| sink.close(); |
| source.close(); |
| } |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException.", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_$LByteBuffer_Exception() throws IOException { |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| source.read(nullBufArrayRef); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| // ByteBuffer array contains null element |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray1 = { nullBuf }; |
| try { |
| source.read(nullBufArray1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| ByteBuffer[] nullBufArray2 = { buffer, nullBuf }; |
| try { |
| source.read(nullBufArray2); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_$LByteBuffer_SinkClosed() throws IOException { |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| ByteBuffer[] readBufArray = { readBuf }; |
| sink.write(buffer); |
| sink.close(); |
| long count = source.read(readBufArray); |
| assertEquals(BUFFER_SIZE, count); |
| // readBuf is full, read 0 byte expected |
| count = source.read(readBufArray); |
| assertEquals(0, count); |
| // readBuf is not null, -1 is expected |
| readBuf.position(0); |
| assertTrue(readBuf.hasRemaining()); |
| count = source.read(readBufArray); |
| assertEquals(-1, count); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies ClosedChannelException, NullPointerException.", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_$LByteBuffer_SourceClosed() throws IOException { |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| ByteBuffer[] readBufArray = { readBuf }; |
| source.close(); |
| try { |
| source.read(readBufArray); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| readBuf.position(BUFFER_SIZE); |
| try { |
| // readBuf is full |
| source.read(readBufArray); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| source.read(nullBufArrayRef); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| // ByteBuffer array contains null element |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray1 = { nullBuf }; |
| try { |
| source.read(nullBufArray1); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_read_$LByteBufferII() throws IOException { |
| ByteBuffer[] bufArray = { buffer, positionedBuffer }; |
| boolean[] sinkBlockingMode = { true, true, false, false }; |
| boolean[] sourceBlockingMode = { true, false, true, false }; |
| for (int i = 0; i < sinkBlockingMode.length; ++i) { |
| Pipe pipe = Pipe.open(); |
| sink = pipe.sink(); |
| source = pipe.source(); |
| |
| sink.configureBlocking(sinkBlockingMode[i]); |
| source.configureBlocking(sourceBlockingMode[i]); |
| |
| buffer.position(0); |
| positionedBuffer.position(BUFFER_SIZE); |
| try { |
| sink.write(bufArray); |
| // invoke close to ensure all data will be sent out |
| sink.close(); |
| // read until EOF is meet or readBufArray is full. |
| ByteBuffer[] readBufArray = { ByteBuffer.allocate(BUFFER_SIZE), |
| ByteBuffer.allocate(BUFFER_SIZE) }; |
| long totalCount = 0; |
| do { |
| long count = source.read(readBufArray, 0, 2); |
| if (count < 0) { |
| break; |
| } |
| if (0 == count && BUFFER_SIZE == readBufArray[1].position()) { |
| // source.read returns 0 because readBufArray is full |
| break; |
| } |
| totalCount += count; |
| } while (totalCount != 10); |
| |
| // assert read result |
| for (ByteBuffer readBuf : readBufArray) { |
| // RI may fail because of its bug implementation |
| assertEquals(BUFFER_SIZE, readBuf.position()); |
| assertEquals("bytes", |
| new String(readBuf.array(), ISO8859_1)); |
| } |
| } finally { |
| sink.close(); |
| source.close(); |
| } |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException, IndexOutOfBoundsException.", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_read_$LByteBufferII_Exception() throws IOException { |
| |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| source.read(nullBufArrayRef, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| try { |
| source.read(nullBufArrayRef, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| // ByteBuffer array contains null element |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray1 = { nullBuf }; |
| try { |
| source.read(nullBufArray1, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| try { |
| source.read(nullBufArray1, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| try { |
| source.read(nullBufArray1, -1, 0); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| try { |
| source.read(nullBufArray1, -1, 1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| ByteBuffer[] nullBufArray2 = { buffer, nullBuf }; |
| |
| try { |
| source.read(nullBufArray1, 1, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| source.read(nullBufArray2, 0, 3); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| source.read(nullBufArray2, 0, 2); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_read_$LByteBufferII_SinkClosed() throws IOException { |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| ByteBuffer[] readBufArray = { readBuf }; |
| sink.write(buffer); |
| sink.close(); |
| long count = source.read(readBufArray, 0, 1); |
| assertEquals(BUFFER_SIZE, count); |
| // readBuf is full, read 0 byte expected |
| count = source.read(readBufArray); |
| assertEquals(0, count); |
| // readBuf is not null, -1 is expected |
| readBuf.position(0); |
| count = source.read(readBufArray, 0, 1); |
| assertEquals(-1, count); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies IndexOutOfBoundsException, ClosedChannelException.", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_read_$LByteBufferII_SourceClosed() throws IOException { |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| ByteBuffer[] readBufArray = { readBuf }; |
| source.close(); |
| try { |
| source.read(readBufArray, 0, 1); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| readBuf.position(BUFFER_SIZE); |
| try { |
| // readBuf is full |
| source.read(readBufArray, 0, 1); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| source.read(nullBufArrayRef, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| try { |
| source.read(nullBufArrayRef, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| // ByteBuffer array contains null element |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray1 = { nullBuf }; |
| try { |
| source.read(nullBufArray1, 0, 1); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| try { |
| source.read(nullBufArray1, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| try { |
| source.read(nullBufArray1, -1, 0); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| try { |
| source.read(nullBufArray1, -1, 1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| ByteBuffer[] nullBufArray2 = { buffer, nullBuf }; |
| |
| try { |
| source.read(nullBufArray1, 1, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| source.read(nullBufArray2, 0, 3); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| source.read(nullBufArray2, 0, 2); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#close() |
| * @tests {@link java.nio.channels.Pipe.SourceChannel#isOpen()} |
| */ |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "close", |
| args = {} |
| ),@TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "isOpen", |
| args = {} |
| ) |
| }) |
| public void test_close() throws IOException { |
| assertTrue(sink.isOpen()); |
| sink.close(); |
| assertFalse(sink.isOpen()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "SourceChannel", |
| args = {java.nio.channels.spi.SelectorProvider.class} |
| ) |
| public void testConstructor() throws IOException { |
| SourceChannel channel = |
| SelectorProvider.provider().openPipe().source(); |
| assertNotNull(channel); |
| assertSame(SelectorProvider.provider(),channel.provider()); |
| channel = Pipe.open().source(); |
| assertNotNull(channel); |
| assertSame(SelectorProvider.provider(),channel.provider()); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies ClosedByInterruptException", |
| method = "read", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_read_LByteBuffer_mutliThread_interrupt() throws Exception { |
| |
| source.configureBlocking(true); |
| |
| Thread thread = new Thread() { |
| public void run() { |
| try { |
| source.read(ByteBuffer.allocate(10)); |
| fail("should have thrown a ClosedByInterruptException."); |
| } catch (ClosedByInterruptException e) { |
| // expected |
| return; |
| } catch (IOException e) { |
| fail("should throw a ClosedByInterruptException but " + |
| "threw " + e.getClass() + ": " + e.getMessage()); |
| } |
| } |
| }; |
| |
| thread.start(); |
| Thread.currentThread().sleep(500); |
| thread.interrupt(); |
| |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer) |
| */ |
| public void disabled_test_read_LByteBuffer_mutliThread_close() throws Exception { |
| |
| ByteBuffer sourceBuf = ByteBuffer.allocate(1000); |
| source.configureBlocking(true); |
| |
| new Thread() { |
| public void run() { |
| try { |
| Thread.currentThread().sleep(500); |
| source.close(); |
| } catch (Exception e) { |
| //ignore |
| } |
| } |
| }.start(); |
| try { |
| source.read(sourceBuf); |
| fail("should throw AsynchronousCloseException"); |
| } catch (AsynchronousCloseException e) { |
| // ok |
| } |
| } |
| } |