| /* 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.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.AndroidOnly; |
| |
| import java.io.IOException; |
| import java.net.InetAddress; |
| import java.net.InetSocketAddress; |
| 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.ServerSocketChannel; |
| import java.nio.channels.SocketChannel; |
| import java.nio.channels.Pipe.SinkChannel; |
| import java.nio.channels.spi.SelectorProvider; |
| |
| import junit.framework.TestCase; |
| |
| /** |
| * Tests for Pipe.SinkChannel class |
| */ |
| @TestTargetClass( |
| value = java.nio.channels.Pipe.SinkChannel.class, |
| untestedMethods = { |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "AsynchronousCloseException can not easily be tested", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "ClosedByInterruptException can not easily be tested", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| } |
| ) |
| public class SinkChannelTest 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.SinkChannel#validOps() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "validOps", |
| args = {} |
| ) |
| public void test_validOps() { |
| assertEquals(SelectionKey.OP_WRITE, sink.validOps()); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer []) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_write_LByteBuffer() throws IOException { |
| ByteBuffer[] bufArray = { buffer, positionedBuffer }; |
| boolean[] sinkBlockingMode = { true, true, false, false }; |
| boolean[] sourceBlockingMode = { true, false, true, false }; |
| int oldPosition; |
| int currentPosition; |
| for (int i = 0; i < sinkBlockingMode.length; ++i) { |
| sink.configureBlocking(sinkBlockingMode[i]); |
| source.configureBlocking(sourceBlockingMode[i]); |
| // if sink and source both are blocking mode, source only needs read |
| // once to get what sink write. |
| boolean isBlocking = sinkBlockingMode[i] && sourceBlockingMode[i]; |
| for (ByteBuffer buf : bufArray) { |
| buf.mark(); |
| oldPosition = buf.position(); |
| sink.write(buf); |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| int totalCount = 0; |
| do { |
| int count = source.read(readBuf); |
| if (count > 0) { |
| totalCount += count; |
| } |
| } while (totalCount != BUFFER_SIZE && !isBlocking); |
| currentPosition = buf.position(); |
| assertEquals(BUFFER_SIZE, currentPosition - oldPosition); |
| assertEquals("bytes", new String(readBuf.array(), ISO8859_1)); |
| buf.reset(); |
| } |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_write_LByteBuffer_mutliThread() throws IOException, |
| InterruptedException { |
| final int THREAD_NUM = 20; |
| final byte[] strbytes = "bytes".getBytes(ISO8859_1); |
| Thread[] thread = new Thread[THREAD_NUM]; |
| for (int i = 0; i < THREAD_NUM; i++) { |
| thread[i] = new Thread() { |
| public void run() { |
| try { |
| sink.write(ByteBuffer.wrap(strbytes)); |
| } catch (IOException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| }; |
| } |
| for (int i = 0; i < THREAD_NUM; i++) { |
| thread[i].start(); |
| } |
| for (int i = 0; i < THREAD_NUM; i++) { |
| thread[i].join(); |
| } |
| ByteBuffer readBuf = ByteBuffer.allocate(THREAD_NUM * BUFFER_SIZE); |
| |
| long totalCount = 0; |
| do { |
| long count = source.read(readBuf); |
| if (count < 0) { |
| break; |
| } |
| totalCount += count; |
| } while (totalCount != (THREAD_NUM * BUFFER_SIZE)); |
| |
| StringBuffer buf = new StringBuffer(); |
| for (int i = 0; i < THREAD_NUM; i++) { |
| buf.append("bytes"); |
| } |
| String readString = buf.toString(); |
| assertEquals(readString, new String(readBuf.array(), ISO8859_1)); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer) |
| */ |
| public void disabled_test_read_LByteBuffer_mutliThread_close() throws Exception { |
| |
| ByteBuffer sourceBuf = ByteBuffer.allocate(1000); |
| sink.configureBlocking(true); |
| |
| new Thread() { |
| public void run() { |
| try { |
| Thread.currentThread().sleep(500); |
| sink.close(); |
| } catch (Exception e) { |
| //ignore |
| } |
| } |
| }.start(); |
| try { |
| sink.write(sourceBuf); |
| fail("should throw AsynchronousCloseException"); |
| } catch (AsynchronousCloseException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer) |
| */ |
| public void disabled_test_read_LByteBuffer_mutliThread_interrupt() throws Exception { |
| |
| sink.configureBlocking(true); |
| |
| Thread thread = new Thread() { |
| public void run() { |
| try { |
| sink.write(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.SinkChannel#write(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException.", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_write_LByteBuffer_Exception() throws IOException { |
| // write null ByteBuffer |
| ByteBuffer nullBuf = null; |
| try { |
| sink.write(nullBuf); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| @AndroidOnly("seems to run on newer RI versions") |
| public void test_write_LByteBuffer_SourceClosed() throws IOException { |
| source.close(); |
| int written = sink.write(buffer); |
| assertEquals(BUFFER_SIZE, written); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies ClosedChannelException, NullPointerException.", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_write_LByteBuffer_SinkClosed() throws IOException { |
| sink.close(); |
| try { |
| sink.write(buffer); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| |
| // write null ByteBuffer |
| ByteBuffer nullBuf = null; |
| try { |
| sink.write(nullBuf); |
| fail("should throw NullPointerException"); |
| } catch (ClosedChannelException e) { |
| // expected on RI |
| } catch (NullPointerException e) { |
| // expected on Harmony/Android |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_write_$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) { |
| sink.configureBlocking(sinkBlockingMode[i]); |
| source.configureBlocking(sourceBlockingMode[i]); |
| buffer.position(0); |
| positionedBuffer.position(BUFFER_SIZE); |
| sink.write(bufArray); |
| // if sink and source both are blocking mode, source only needs read |
| // once to get what sink write. |
| boolean isBlocking = sinkBlockingMode[i] && sourceBlockingMode[i]; |
| for (int j = 0; j < bufArray.length; ++j) { |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| int totalCount = 0; |
| do { |
| int count = source.read(readBuf); |
| if (count < 0) { |
| break; |
| } |
| totalCount += count; |
| } while (totalCount != BUFFER_SIZE && !isBlocking); |
| assertEquals("bytes", new String(readBuf.array(), ISO8859_1)); |
| } |
| assertEquals(BUFFER_SIZE, buffer.position()); |
| assertEquals(10, positionedBuffer.position()); |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException.", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_write_$LByteBuffer_Exception() throws IOException { |
| // write null ByteBuffer[] |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| sink.write(nullBufArrayRef); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| // write ByteBuffer[] contains null element |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray = { buffer, nullBuf }; |
| try { |
| sink.write(nullBufArray); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| @AndroidOnly("seems to run on newer RI versions") |
| public void test_write_$LByteBuffer_SourceClosed() throws IOException { |
| ByteBuffer[] bufArray = { buffer }; |
| source.close(); |
| long written = sink.write(bufArray); |
| assertEquals(BUFFER_SIZE, written); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[]) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies ClosedChannelException, NullPointerException.", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class} |
| ) |
| public void test_write_$LByteBuffer_SinkClosed() throws IOException { |
| ByteBuffer[] bufArray = { buffer }; |
| sink.close(); |
| try { |
| sink.write(bufArray); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| sink.write(nullBufArrayRef); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray = { nullBuf }; |
| // write ByteBuffer[] contains null element |
| try { |
| sink.write(nullBufArray); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_write_$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) { |
| sink.configureBlocking(sinkBlockingMode[i]); |
| source.configureBlocking(sourceBlockingMode[i]); |
| positionedBuffer.position(BUFFER_SIZE); |
| sink.write(bufArray, 1, 1); |
| // if sink and source both are blocking mode, source only needs read |
| // once to get what sink write. |
| boolean isBlocking = sinkBlockingMode[i] && sourceBlockingMode[i]; |
| ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE); |
| int totalCount = 0; |
| do { |
| int count = source.read(readBuf); |
| if (count < 0) { |
| break; |
| } |
| totalCount += count; |
| } while (totalCount != BUFFER_SIZE && !isBlocking); |
| assertEquals("bytes", new String(readBuf.array(), ISO8859_1)); |
| assertEquals(10, positionedBuffer.position()); |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException, IndexOutOfBoundsException.", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_write_$LByteBufferII_Exception() throws IOException { |
| // write null ByteBuffer[] |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| sink.write(nullBufArrayRef, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(nullBufArrayRef, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| // write ByteBuffer[] contains null element |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray = { nullBuf }; |
| try { |
| sink.write(nullBufArray, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(nullBufArray, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| ByteBuffer[] bufArray = { buffer, nullBuf }; |
| try { |
| sink.write(bufArray, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray, -1, 0); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray, -1, 1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray, 0, 3); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray, 0, 2); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| @AndroidOnly("seems to run on newer RI versions") |
| public void test_write_$LByteBufferII_SourceClosed() throws IOException { |
| ByteBuffer[] bufArray = { buffer }; |
| source.close(); |
| long written = sink.write(bufArray, 0, 1); |
| assertEquals(BUFFER_SIZE, written); |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies ClosedChannelException, NullPointerException, IndexOutOfBoundsException.", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_write_$LByteBufferII_SinkClosed() throws IOException { |
| ByteBuffer[] bufArray = { buffer }; |
| sink.close(); |
| try { |
| sink.write(bufArray, 0, 1); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| |
| // write null ByteBuffer[] |
| ByteBuffer[] nullBufArrayRef = null; |
| try { |
| sink.write(nullBufArrayRef, 0, 1); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| // illegal array index |
| try { |
| sink.write(nullBufArrayRef, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| // write ByteBuffer[] contains null element |
| ByteBuffer nullBuf = null; |
| ByteBuffer[] nullBufArray = { nullBuf }; |
| try { |
| sink.write(nullBufArray, 0, 1); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| // illegal array index |
| try { |
| sink.write(nullBufArray, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| ByteBuffer[] bufArray2 = { buffer, nullBuf }; |
| // illegal array index |
| try { |
| sink.write(bufArray2, 0, -1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray2, -1, 0); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray2, -1, 1); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray2, 0, 3); |
| fail("should throw IndexOutOfBoundsException"); |
| } catch (IndexOutOfBoundsException e) { |
| // expected |
| } |
| |
| try { |
| sink.write(bufArray2, 0, 2); |
| fail("should throw ClosedChannelException"); |
| } catch (ClosedChannelException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @tests java.nio.channels.Pipe.SinkChannel#close() |
| * @tests {@link java.nio.channels.Pipe.SinkChannel#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 = "SinkChannel", |
| args = {java.nio.channels.spi.SelectorProvider.class} |
| ) |
| public void testConstructor() throws IOException { |
| SinkChannel channel = |
| SelectorProvider.provider().openPipe().sink(); |
| assertNotNull(channel); |
| assertSame(SelectorProvider.provider(),channel.provider()); |
| channel = Pipe.open().sink(); |
| assertNotNull(channel); |
| assertSame(SelectorProvider.provider(),channel.provider()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies that NullPointerException is thrown if write" + |
| "method is called for closed channel.", |
| method = "write", |
| args = {java.nio.ByteBuffer.class} |
| ) |
| public void test_socketChannel_closed() throws Exception { |
| ServerSocketChannel ssc = ServerSocketChannel.open(); |
| ssc.socket().bind(new InetSocketAddress(InetAddress.getLocalHost(),49999)); |
| SocketChannel sc = SocketChannel.open(); |
| ByteBuffer buf = null; |
| try{ |
| sc.write(buf); |
| fail("should throw NPE"); |
| }catch (NullPointerException e){ |
| // expected |
| } |
| sc.connect(new InetSocketAddress(InetAddress.getLocalHost(),49999)); |
| SocketChannel sock = ssc.accept(); |
| ssc.close(); |
| sc.close(); |
| try{ |
| sc.write(buf); |
| fail("should throw NPE"); |
| }catch (NullPointerException e){ |
| // expected |
| } |
| sock.close(); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Verifies NullPointerException.", |
| method = "write", |
| args = {java.nio.ByteBuffer[].class, int.class, int.class} |
| ) |
| public void test_socketChannel_empty() throws Exception { |
| ServerSocketChannel ssc = ServerSocketChannel.open(); |
| ssc.socket().bind(new InetSocketAddress(InetAddress.getLocalHost(),49999)); |
| SocketChannel sc = SocketChannel.open(); |
| sc.connect(new InetSocketAddress(InetAddress.getLocalHost(),49999)); |
| SocketChannel sock = ssc.accept(); |
| ByteBuffer[] buf = {ByteBuffer.allocate(10),null}; |
| try{ |
| sc.write(buf,0,2); |
| fail("should throw NPE"); |
| }catch (NullPointerException e){ |
| // expected |
| } |
| ssc.close(); |
| sc.close(); |
| ByteBuffer target = ByteBuffer.allocate(10); |
| assertEquals(-1, sock.read(target)); |
| } |
| } |