/*
* 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.TestTargets;
//import dalvik.annotation.TestTargetNew;
//import dalvik.annotation.TestTargetClass;
//import dalvik.annotation.TestLevel;
//import dalvik.annotation.AndroidOnly;
//import dalvik.annotation.BrokenTest;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.BindException;
import java.net.ConnectException;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.nio.ByteBuffer;
import java.nio.channels.AlreadyConnectedException;
import java.nio.channels.ClosedChannelException;
import java.nio.channels.ConnectionPendingException;
import java.nio.channels.IllegalBlockingModeException;
import java.nio.channels.NoConnectionPendingException;
import java.nio.channels.NotYetConnectedException;
import java.nio.channels.SelectableChannel;
import java.nio.channels.SelectionKey;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels.UnresolvedAddressException;
import java.nio.channels.UnsupportedAddressTypeException;
import java.nio.channels.spi.SelectorProvider;
import junit.framework.TestCase;
import tests.support.Support_PortManager;
//@TestTargetClass(SocketChannel.class)
/**
* Tests for SocketChannel and its default implementation.
*/
public class SocketChannelTest extends TestCase {
private static final int CAPACITY_NORMAL = 200;
private static final int CAPACITY_HUGE = 512 * 1024;
private InetSocketAddress localAddr1;
private InetSocketAddress localAddr2;
private SocketChannel channel1;
private SocketChannel channel2;
private ServerSocket server1;
private ServerSocket server2;
private final static int TIMEOUT = 60000;
private final static int EOF = -1;
protected void setUp() throws Exception {
super.setUp();
this.localAddr1 = new InetSocketAddress("127.0.0.1",
Support_PortManager.getNextPort());
this.localAddr2 = new InetSocketAddress("127.0.0.1",
Support_PortManager.getNextPort());
this.channel1 = SocketChannel.open();
this.channel2 = SocketChannel.open();
this.server1 = new ServerSocket(localAddr1.getPort());
}
protected void tearDown() throws Exception {
super.tearDown();
if (null != this.channel1) {
try {
this.channel1.close();
} catch (Exception e) {
// ignore
}
}
if (null != this.channel2) {
try {
this.channel2.close();
} catch (Exception e) {
// ignore
}
}
if (null != this.server1) {
try {
this.server1.close();
} catch (Exception e) {
// ignore
}
}
if (null != this.server2) {
try {
this.server2.close();
} catch (Exception e) {
// ignore
}
}
}
// -------------------------------------------------------------------
// Test for methods in abstract class.
// -------------------------------------------------------------------
/*
* Test method for 'java.nio.channels.SocketChannel()'
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "SocketChannel",
args = {SelectorProvider.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "provider",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "open",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
clazz = SelectorProvider.class,
method = "openSocketChannel",
args = {}
)
})
*/
public void testConstructor() throws IOException {
SocketChannel channel =
SelectorProvider.provider().openSocketChannel();
assertNotNull(channel);
assertSame(SelectorProvider.provider(), channel.provider());
channel = SocketChannel.open();
assertNotNull(channel);
assertSame(SelectorProvider.provider(), channel.provider());
MockSocketChannel chan = new MockSocketChannel(
SelectorProvider.provider());
assertTrue(chan.isConstructorCalled);
}
/*
* Test method for 'java.nio.channels.SocketChannel.validOps()'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "validOps",
args = {}
)
*/
public void testValidOps() {
MockSocketChannel testMSChannel = new MockSocketChannel(null);
assertEquals(13, this.channel1.validOps());
assertEquals(13, testMSChannel.validOps());
}
/*
* Test method for 'java.nio.channels.SocketChannel.open()'
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "open",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "SocketChannel",
args = {SelectorProvider.class}
)
})
*/
public void testOpen() throws IOException {
java.nio.ByteBuffer[] buf = new java.nio.ByteBuffer[1];
buf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
MockSocketChannel testMSChannel = new MockSocketChannel(null);
MockSocketChannel testMSChannelnotnull = new MockSocketChannel(
SelectorProvider.provider());
SocketChannel testSChannel = MockSocketChannel.open();
assertTrue(testSChannel.isOpen());
assertNull(testMSChannel.provider());
assertNotNull(testSChannel.provider());
assertEquals(SelectorProvider.provider(), testSChannel.provider());
assertNotNull(testMSChannelnotnull.provider());
assertEquals(this.channel1.provider(), testMSChannelnotnull.provider());
try {
this.channel1.write(buf);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "isOpen",
args = {}
)
*/
public void testIsOpen() throws Exception {
assertTrue(this.channel1.isOpen());
this.channel1.close();
assertFalse(this.channel1.isOpen());
}
/*
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isConnected",
args = {}
)
*/
public void testIsConnected() throws Exception {
assertFalse(this.channel1.isConnected());// not connected
this.channel1.configureBlocking(false);
assertFalse(this.channel1.connect(localAddr1));
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
assertTrue(tryFinish());
assertTrue(this.channel1.isConnected());
this.channel1.close();
assertFalse(this.channel1.isConnected());
}
/*
@TestTargetNew(
level = TestLevel.COMPLETE,
notes = "",
method = "isConnectionPending",
args = {}
)
*/
public void testIsConnectionPending() throws Exception {
// ensure
ensureServerClosed();
this.channel1.configureBlocking(false);
assertFalse(this.channel1.isConnectionPending());
// finish
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// OK.
}
assertFalse(this.channel1.isConnectionPending());
// connect
assertFalse(this.channel1.connect(localAddr1));
assertTrue(this.channel1.isConnectionPending());
this.channel1.close();
assertFalse(this.channel1.isConnectionPending());
}
/*
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies default status of SocketChannel.",
method = "validOps",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies default status of SocketChannel.",
method = "provider",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies default status of SocketChannel.",
method = "isRegistered",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies default status of SocketChannel.",
method = "isBlocking",
args = {}
)
})
*/
public void testChannelBasicStatus() {
Socket gotSocket = this.channel1.socket();
assertFalse(gotSocket.isClosed());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isRegistered());
assertEquals((SelectionKey.OP_CONNECT | SelectionKey.OP_READ |
SelectionKey.OP_WRITE), this.channel1.validOps());
assertEquals(SelectorProvider.provider(), this.channel1.provider());
}
/*
* Test method for 'java.nio.channels.SocketChannel.open(SocketAddress)'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "open",
args = {java.net.SocketAddress.class}
)
*/
public void testOpenSocketAddress() throws IOException {
this.channel1 = SocketChannel.open(localAddr1);
assertTrue(this.channel1.isConnected());
SecurityManager smngr = System.getSecurityManager();
System.setSecurityManager(new MockSecurityManager("blargh"));
try {
this.channel1 = SocketChannel.open(localAddr2);
fail("Should throw SecurityException");
} catch (SecurityException e) {
// expected
}
System.setSecurityManager(smngr);
SocketAddress newTypeAddress = new SubSocketAddress();
try {
this.channel1 = SocketChannel.open(newTypeAddress);
fail("Should throw UnexpectedAddressTypeException");
} catch (UnsupportedAddressTypeException e) {
// expected
}
SocketAddress unresolvedAddress =
InetSocketAddress.createUnresolved("127.0.0.1", 8080);
try {
this.channel1 = SocketChannel.open(unresolvedAddress);
fail("Should throw UnresolvedAddressException");
} catch (UnresolvedAddressException e) {
// expected
}
SocketChannel channel1IP = null;
try {
channel1IP = SocketChannel.open(null);
fail("Should throw an IllegalArgumentException");
} catch (IllegalArgumentException e) {
// correct
}
assertNull(channel1IP);
}
/*
* Test method for 'java.nio.channels.SocketChannel.read(ByteBuffer[])'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void testReadByteBufferArray() throws IOException {
java.nio.ByteBuffer[] byteBuf = null;
MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
MockSocketChannel testMSChannel = new MockSocketChannel(
SelectorProvider.provider());
ServerSocket testServer = new ServerSocket(Support_PortManager
.getNextPort());
try {
try {
this.channel1.read(byteBuf);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
byteBuf = new java.nio.ByteBuffer[CAPACITY_NORMAL];
try {
this.channel1.read(byteBuf);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
long readNum = CAPACITY_NORMAL;
readNum = testMSChannel.read(byteBuf);
assertEquals(0, readNum);
readNum = CAPACITY_NORMAL;
readNum = testMSChannelnull.read(byteBuf);
assertEquals(0, readNum);
} finally {
testServer.close();
}
}
/*
* Test method for 'java.nio.channels.SocketChannel.read(ByteBuffer[])'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void testReadByteBufferArray_BufNull() throws IOException {
java.nio.ByteBuffer[] byteBuf = null;
MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
MockSocketChannel testMSChannel = new MockSocketChannel(
SelectorProvider.provider());
try {
this.channel1.read(byteBuf);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
try {
testMSChannel.read(byteBuf);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
try {
testMSChannelnull.read(byteBuf);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
}
/*
* Test method for 'java.nio.channels.SocketChannel.write(ByteBuffer[])'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify AsynchronousCloseException," +
"ClosedByInterruptException.",
method = "write",
args = {java.nio.ByteBuffer[].class}
)
*/
public void testWriteByteBufferArray() throws IOException {
java.nio.ByteBuffer[] byteBuf = null;
MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
MockSocketChannel testMSChannel = new MockSocketChannel(
SelectorProvider.provider());
try {
this.channel1.write(byteBuf);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
byteBuf = new java.nio.ByteBuffer[1];
byteBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
try {
this.channel1.write(byteBuf);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
testMSChannel.write(byteBuf);
testMSChannelnull.write(byteBuf);
this.channel1.close();
try {
this.channel1.write(byteBuf);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
* Test method for 'java.nio.channels.SocketChannel.write(ByteBuffer[])'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer[].class}
)
*/
public void testWriteByteBufferArray_BufNull() throws IOException {
java.nio.ByteBuffer[] byteBuf = null;
MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
MockSocketChannel testMSChannel = new MockSocketChannel(
SelectorProvider.provider());
this.channel1.connect(localAddr1);
try {
this.channel1.write(byteBuf);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
byteBuf = new java.nio.ByteBuffer[1];
try {
this.channel1.write(byteBuf);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
@AndroidOnly("Fails on RI. See comment below")
public void testSocket_BasicStatusBeforeConnect() throws IOException {
assertFalse(this.channel1.isConnected());// not connected
Socket s1 = this.channel1.socket();
// RI fails here. RI returns 0 while spec says getLocalPort()
// shall return -1 for unbound socket
assertSocketBeforeConnect(s1);
Socket s2 = this.channel1.socket();
// same
assertSame(s1, s2);
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
public void testSocket_Block_BasicStatusAfterConnect() throws IOException {
assertFalse(this.channel1.isConnected());// not connected
assertTrue(this.channel1.connect(localAddr1));
assertTrue(this.channel1.isConnected());
Socket s1 = this.channel1.socket();
assertSocketAfterConnect(s1, localAddr1);
Socket s2 = this.channel1.socket();
// same
assertSame(s1, s2);
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
@AndroidOnly("Fails on RI. See comment below")
public void testSocket_NonBlock_BasicStatusAfterConnect() throws Exception {
assertFalse(this.channel1.isConnected());// not connected
this.channel1.configureBlocking(false);
assertFalse(this.channel1.connect(localAddr1));
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
Socket s1 = this.channel1.socket();
// status of not connected
// RI fails here. RI returns 0 while spec says getLocalPort()
// shall return -1 for unbound socket
assertSocketBeforeConnect(s1);
Socket s2 = this.channel1.socket();
// same
assertSame(s1, s2);
assertTrue(tryFinish());
assertTrue(this.channel1.isConnected());
s1 = this.channel1.socket();
assertSocketAfterConnect(s1, localAddr1);
s2 = this.channel1.socket();
// same
assertSame(s1, s2);
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
public void testSocket_Block_ActionsBeforeConnect() throws IOException {
assertFalse(this.channel1.isConnected());// not connected
Socket s = this.channel1.socket();
assertSocketAction_Block_BeforeConnect(s);
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
public void testSocket_Block_ActionsAfterConnect() throws IOException {
assertFalse(this.channel1.isConnected());// not connected
assertTrue(this.channel1.connect(localAddr1));
assertTrue(this.channel1.isConnected());
Socket s = this.channel1.socket();
assertSocketAction_Block_AfterConnect(s);
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
public void testSocket_NonBlock_ActionsAfterConnectBeforeFinish()
throws IOException {
assertFalse(this.channel1.isConnected());// not connected
this.channel1.configureBlocking(false);
assertFalse(this.channel1.connect(localAddr1));
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
Socket s1 = this.channel1.socket();
// Action of not connected
assertSocketAction_NonBlock_BeforeConnect(s1);
Socket s2 = this.channel1.socket();
// same
assertSame(s1, s2);
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
public void testSocket_NonBlock_ActionsAfterConnectAfterFinish()
throws Exception {
assertFalse(this.channel1.isConnected());// not connected
this.channel1.configureBlocking(false);
assertFalse(this.channel1.connect(localAddr1));
assertTrue(tryFinish());
Socket s1 = this.channel1.socket();
assertSocketAction_NonBlock_AfterConnect(s1);
Socket s2 = this.channel1.socket();
// same
assertSame(s1, s2);
}
private void assertSocketBeforeConnect(Socket s) throws IOException {
assertFalse(s.isBound());
assertFalse(s.isClosed());
assertFalse(s.isConnected());
assertFalse(s.getKeepAlive());
try {
s.getInputStream();
fail("Should throw SocketException.");
} catch (SocketException e) {
// OK.
}
assertFalse(s.getOOBInline());
try {
s.getOutputStream();
fail("Should throw SocketException.");
} catch (SocketException e) {
// OK.
}
assertEquals(-1, s.getSoLinger());
assertFalse(s.getTcpNoDelay());
assertFalse(s.isInputShutdown());
assertFalse(s.isOutputShutdown());
assertNull(s.getInetAddress());
assertEquals(s.getLocalAddress().getHostAddress(), "0.0.0.0");
assertFalse(s.getReuseAddress());
assertNull(s.getLocalSocketAddress());
// not connected
assertEquals(0, s.getPort());
assertTrue(s.getReceiveBufferSize() >= 8192);
assertNull(s.getRemoteSocketAddress());
assertTrue(s.getSendBufferSize() >= 8192);
assertEquals(0, s.getSoTimeout());
assertEquals(0, s.getTrafficClass());
// RI fails here. RI returns 0 while spec says unbound socket should
// return -1.
assertEquals(-1, s.getLocalPort());
}
private void assertSocketAfterConnect(Socket s, InetSocketAddress address)
throws IOException {
assertTrue(s.isBound());
assertFalse(s.isClosed());
assertTrue(s.isConnected());
assertFalse(s.getKeepAlive());
assertNotNull(s.getInputStream());
assertNotNull(s.getOutputStream());
assertFalse(s.getOOBInline());
assertEquals(-1, s.getSoLinger());
assertFalse(s.getTcpNoDelay());
assertFalse(s.isInputShutdown());
assertFalse(s.isOutputShutdown());
assertSame(s.getInetAddress(), address.getAddress());
assertEquals(this.localAddr1.getAddress(), s.getLocalAddress());
assertEquals(address.getPort(), s.getPort());
assertNotNull(s.getLocalSocketAddress());
assertTrue(s.getReceiveBufferSize() >= 8192);
// equal , not same
assertNotSame(address, s.getRemoteSocketAddress());
assertEquals(address, s.getRemoteSocketAddress());
// assertFalse(s.getReuseAddress());
assertTrue(s.getSendBufferSize() >= 8192);
assertEquals(0, s.getSoTimeout());
assertEquals(0, s.getTrafficClass());
}
private void assertSocketAction_Block_BeforeConnect(Socket s)
throws IOException {
assertFalse(this.channel1.isConnected());
this.server2 = new ServerSocket(localAddr2.getPort());
s.connect(localAddr2);
assertTrue(this.channel1.isConnected());
assertTrue(s.isConnected());
assertSocketAfterConnect(s, localAddr2);
try {
s.bind(localAddr2);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// OK.
}
s.close();
assertTrue(s.isClosed());
assertFalse(this.channel1.isOpen());
}
private void assertSocketAction_NonBlock_BeforeConnect(Socket s)
throws IOException {
assertFalse(this.channel1.isConnected());
this.server2 = new ServerSocket(localAddr2.getPort());
try {
s.connect(localAddr2);
fail("Should throw IllegalBlockingModeException");
} catch (IllegalBlockingModeException e1) {
// OK.
}
if (this.channel1.isConnectionPending()) {
try {
s.bind(localAddr2);
fail("Should throw ConnectionPendingException");
} catch (ConnectionPendingException e1) {
// OK.
}
} else {
try {
s.bind(localAddr2);
fail("Should throw BindException");
} catch (BindException e1) {
// OK.
}
}
assertFalse(this.channel1.isConnected());
assertFalse(s.isConnected());
s.close();
assertTrue(s.isClosed());
assertFalse(this.channel1.isOpen());
}
private void assertSocketAction_Block_AfterConnect(Socket s)
throws IOException {
assertEquals(localAddr1.getPort(), s.getPort());
assertTrue(this.channel1.isConnected());
assertTrue(s.isConnected());
try {
s.connect(localAddr2);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// OK.
}
try {
s.bind(localAddr2);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// OK.
}
s.close();
assertTrue(s.isClosed());
assertFalse(this.channel1.isOpen());
}
private void assertSocketAction_NonBlock_AfterConnect(Socket s)
throws IOException {
assertEquals(localAddr1.getPort(), s.getPort());
assertTrue(this.channel1.isConnected());
assertTrue(s.isConnected());
if (this.channel1.isConnectionPending()) {
try {
s.connect(localAddr2);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// OK.
}
} else {
try {
s.connect(localAddr2);
fail("Should throw IllegalBlockingModeException");
} catch (IllegalBlockingModeException e) {
// OK.
}
}
try {
s.bind(localAddr2);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// OK.
}
s.close();
assertTrue(s.isClosed());
assertFalse(this.channel1.isOpen());
}
// -------------------------------------------------------------------
// Tests for connect(), finishConnect(),isConnected(),isConnectionPending()
// These methods are very close, so we test them together, call them "CFII".
// -------------------------------------------------------------------
/**
* connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_Norml_NoServer_Block() throws Exception {
// ensure
ensureServerClosed();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// connect
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectException here.");
} catch (ConnectException e) {
// OK.
}
statusChannelClosed();
try {
this.channel1.finishConnect();
fail("Should throw a ClosedChannelException here.");
} catch (ClosedChannelException e) {
// OK.
}
}
/**
* connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_Norml_NoServer_NonBlock() throws Exception {
connectNoServerNonBlock();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_Norml_Server_Block() throws Exception {
connectServerBlock();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_Norml_Server_NonBlock() throws Exception {
connectServerNonBlock();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->server closed-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ServerClosed_Block() throws Exception {
// ensure
ensureServerOpen();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// connect
assertTrue(this.channel1.connect(localAddr1));
statusConnected_NotPending();
ensureServerClosed();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->server closed-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ServerClosed_NonBlock() throws Exception {
// ensure
ensureServerOpen();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
ensureServerClosed();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->server closed-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ServerClosedAfterFinish_Block() throws Exception {
connectServerBlock();
ensureServerClosed();
assertTrue(this.channel1.isOpen());
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->server closed-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ServerClosedAfterFinish_NonBlock() throws Exception {
connectServerNonBlock();
ensureServerClosed();
assertTrue(this.channel1.isOpen());
this.channel1.close();
statusChannelClosed();
}
/**
* no server-->connect-->server open-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ServerStartLater_Block() throws Exception {
// ensure
ensureServerClosed();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// connect
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectException here.");
} catch (ConnectException e) {
// OK.
}
statusChannelClosed();
ensureServerOpen();
try {
this.channel1.finishConnect();
fail("Should throw a ClosedChannelException here.");
} catch (ClosedChannelException e) {
// OK.
}
}
/**
* no server-->connect-->server open-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ServerStartLater_NonBlock() throws Exception {
// ensure
ensureServerClosed();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
ensureServerOpen();
try {
assertFalse(this.channel1.finishConnect());
statusNotConnected_Pending();
this.channel1.close();
} catch (ConnectException e) {
// OK
}
}
/**
* connect-->finish-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_FinishTwice_NoServer_NonBlock() throws Exception {
// ensure
ensureServerClosed();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
try {
assertFalse(this.channel1.finishConnect());
} catch (ConnectException e) {
// OK
}
statusChannelClosed();
try {
assertFalse(this.channel1.finishConnect());
} catch (ClosedChannelException e) {
// OK
}
statusChannelClosed();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_FinishTwice_Server_Block() throws Exception {
connectServerBlock();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_FinishTwice_Server_NonBlock() throws Exception {
connectServerNonBlock();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->connect-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case: connect-->finish-->connect-->close. Verifies ClosedChannelException, ConnectException.",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case: connect-->finish-->connect-->close. Verifies ClosedChannelException, ConnectException.",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ConnectAfterFinish_NoServer_Block() throws Exception {
// ensure
ensureServerClosed();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// connect
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectException here.");
} catch (ConnectException e) {
// OK.
}
statusChannelClosed();
try {
this.channel1.finishConnect();
fail("Should throw a ClosedChannelException here.");
} catch (ClosedChannelException e) {
// OK.
}
statusChannelClosed();
try {
this.channel1.connect(localAddr1);
fail("Should throw a ClosedChannelException here.");
} catch (ClosedChannelException e) {
// OK.
}
statusChannelClosed();
}
/**
* connect-->finish-->connect-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case: connect-->finish-->connect-->close. Verifies ConnectionPendingException, ConnectException.",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case: connect-->finish-->connect-->close. Verifies ConnectionPendingException, ConnectException.",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ConnectAfterFinish_NoServer_NonBlock()
throws Exception {
// ensure
ensureServerClosed();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
// connect another addr
try {
this.channel1.connect(localAddr2);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
// connect if server closed
ensureServerClosed();
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->connect-->close
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies AlreadyConnectedException.",
method = "connect",
args = {java.net.SocketAddress.class}
)
*/
public void testCFII_ConnectAfterFinish_Server_Block() throws Exception {
connectServerBlock();
if (!this.channel1.isConnected()) {
fail("Connection failed," +
"testCFII_ConnectAfterFinish_Server_Block not finished.");
}
try {
this.channel1.connect(localAddr1);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
// connect another addr
try {
this.channel1.connect(localAddr2);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
// connect if server closed
ensureServerClosed();
try {
this.channel1.connect(localAddr1);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->finish-->connect-->close
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies AlreadyConnectedException.",
method = "connect",
args = {java.net.SocketAddress.class}
)
*/
public void testCFII_ConnectAfterFinish_Server_NonBlock() throws Exception {
connectServerNonBlock();
if (!this.channel1.isConnected()) {
fail("Connection failed," +
"testCFII_ConnectAfterFinish_Server_Block not finished.");
}
try {
this.channel1.connect(localAddr1);
fail("Should throw an AlreadyConnectedException or a ConnectionPendingException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
// connect another addr
try {
this.channel1.connect(localAddr2);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
// connect if server closed
ensureServerClosed();
try {
this.channel1.connect(localAddr1);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case: connect-->connect-->finish-->close. Verifies ConnectionPendingException, ConnectException.",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case: connect-->connect-->finish-->close. Verifies ConnectionPendingException, ConnectException.",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ConnectTwice_NoServer_NonBlock() throws Exception {
// ensure
ensureServerClosed();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
// connect another addr
try {
this.channel1.connect(localAddr2);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
// connect if server closed
ensureServerClosed();
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case connect-->connect-->finish-->close. Verifies AlreadyConnectedException.",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case connect-->connect-->finish-->close. Verifies AlreadyConnectedException.",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ConnectTwice_Server_Block() throws Exception {
// ensure
ensureServerOpen();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// connect
assertTrue(this.channel1.connect(localAddr1));
statusConnected_NotPending();
try {
this.channel1.connect(localAddr1);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
// connect another addr
try {
this.channel1.connect(localAddr2);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
// connect if server closed
ensureServerClosed();
try {
this.channel1.connect(localAddr1);
fail("Should throw an AlreadyConnectedException here.");
} catch (AlreadyConnectedException e) {
// OK.
}
statusConnected_NotPending();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/**
* connect-->connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case connect-->connect-->finish-->close. Verifies ConnectionPendingException.",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies case connect-->connect-->finish-->close. Verifies ConnectionPendingException.",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_ConnectTwice_Server_NonBlock() throws Exception {
// ensure
ensureServerOpen();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
// connect another addr
try {
this.channel1.connect(localAddr2);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
// connect if server closed
ensureServerClosed();
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectionPendingException here.");
} catch (ConnectionPendingException e) {
// OK.
}
statusNotConnected_Pending();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/**
* finish-->connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_FinishFirst_NoServer_Block() throws Exception {
// ensure
ensureServerClosed();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// finish
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// OK.
}
statusNotConnected_NotPending();
// connect
try {
this.channel1.connect(localAddr1);
fail("Should throw a ConnectException here.");
} catch (ConnectException e) {
// OK.
}
statusChannelClosed();
try {
this.channel1.finishConnect();
fail("Should throw a ClosedChannelException here.");
} catch (ClosedChannelException e) {
// OK.
}
statusChannelClosed();
}
/**
* finish-->connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_FinishFirst_NoServer_NonBlock() throws Exception {
// ensure
ensureServerClosed();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// finish
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// OK.
}
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
this.channel1.close();
statusChannelClosed();
}
/**
* finish-->connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_FinishFirst_Server_Block() throws Exception {
// ensure
ensureServerOpen();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// finish
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// OK.
}
statusNotConnected_NotPending();
// connect
assertTrue(this.channel1.connect(localAddr1));
statusConnected_NotPending();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/**
* finish-->connect-->finish-->close
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_FinishFirst_Server_NonBlock() throws Exception {
// ensure
ensureServerOpen();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// finish
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// OK.
}
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
tryFinish();
this.channel1.close();
statusChannelClosed();
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
)
*/
public void testCFII_Null() throws Exception {
statusNotConnected_NotPending();
try {
this.channel1.connect(null);
fail("Should throw an IllegalArgumentException here.");
} catch (IllegalArgumentException e) {
// OK.
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
)
*/
public void testCFII_UnsupportedType() throws Exception {
statusNotConnected_NotPending();
SocketAddress newTypeAddress = new SubSocketAddress();
try {
this.channel1.connect(newTypeAddress);
fail("Should throw an UnsupportedAddressTypeException here.");
} catch (UnsupportedAddressTypeException e) {
// OK.
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
)
*/
public void testCFII_Unresolved() throws IOException {
statusNotConnected_NotPending();
InetSocketAddress unresolved = new InetSocketAddress(
"unresolved address", 1080);
try {
this.channel1.connect(unresolved);
fail("Should throw an UnresolvedAddressException here.");
} catch (UnresolvedAddressException e) {
// OK.
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
)
*/
public void testCFII_EmptyHost() throws Exception {
statusNotConnected_NotPending();
ServerSocket server = new ServerSocket(0);
int port = server.getLocalPort();
server.close();
try {
this.channel1.connect(new InetSocketAddress("", port));
fail("Should throw ConnectException");
} catch (ConnectException e) {
// correct
}
}
/*
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies ClosedChannelException.",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies ClosedChannelException.",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_CloseFirst() throws Exception {
this.channel1.close();
statusChannelClosed();
ensureServerOpen();
try {
this.channel1.connect(localAddr1);
fail("Should throw ClosedChannelException.");
} catch (ClosedChannelException e) {
// OK.
}
statusChannelClosed();
try {
this.channel1.finishConnect();
fail("Should throw ClosedChannelException.");
} catch (ClosedChannelException e) {
// OK.
}
statusChannelClosed();
try {
this.channel1.configureBlocking(false);
fail("Should throw ClosedChannelException.");
} catch (ClosedChannelException e) {
// OK.
}
statusChannelClosed();
}
/*
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_StatusAfterFinish() throws Exception {
// 1. close server, finish must return false, check the status
ensureServerClosed();
// 1.1 block mode
assertTrue(this.channel1.isBlocking());
try {
channel1.connect(localAddr1);
fail("Should throw ConnectException");
} catch (ConnectException e) {
// OK.
}
assertFalse(this.channel1.isOpen());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnectionPending());
// 1.2 non block mode
this.channel1 = SocketChannel.open();
this.channel1.configureBlocking(false);
assertFalse(this.channel1.connect(localAddr1));
try {
assertFalse(this.channel1.finishConnect());
fail("Should throw IOException: Connection refused");
} catch (ConnectException e) {
// OK
}
statusChannelClosed();
// 2. start server, finish usually return true, check the status
ensureServerOpen();
// 2.1 block mode
this.channel1 = SocketChannel.open();
assertTrue(this.channel1.isBlocking());
assertTrue(this.channel1.connect(localAddr1));
assertTrue(this.channel1.finishConnect());
statusConnected_NotPending();
this.channel1.close();
// 2.2 non block mode
this.channel1 = SocketChannel.open();
this.channel1.configureBlocking(false);
assertFalse(this.channel1.connect(localAddr1));
tryFinish();
this.channel1.close();
}
private void ensureServerClosed() throws IOException {
if (null != this.server1) {
this.server1.close();
assertTrue(this.server1.isClosed());
}
if (null != this.server2) {
this.server2.close();
assertTrue(this.server2.isClosed());
}
}
private void ensureServerOpen() throws IOException {
ensureServerClosed();
this.server1 = new ServerSocket(localAddr1.getPort());
this.server2 = new ServerSocket(localAddr2.getPort());
assertTrue(this.server1.isBound());
assertTrue(this.server2.isBound());
}
private void connectNoServerNonBlock() throws Exception {
// ensure
ensureServerClosed();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
try {
assertFalse(this.channel1.finishConnect());
} catch (ConnectException e) {
// OK
}
ensureServerClosed();
}
private void connectServerNonBlock() throws Exception {
// ensure
ensureServerOpen();
this.channel1.configureBlocking(false);
statusNotConnected_NotPending();
// connect
assertFalse(this.channel1.connect(localAddr1));
statusNotConnected_Pending();
tryFinish();
}
private void connectServerBlock() throws Exception {
// ensure
ensureServerOpen();
assertTrue(this.channel1.isBlocking());
statusNotConnected_NotPending();
// connect
assertTrue(this.channel1.connect(localAddr1));
statusConnected_NotPending();
tryFinish();
}
private void statusChannelClosed() {
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertFalse(this.channel1.isOpen());
}
private void statusNotConnected_NotPending() {
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
}
private void statusNotConnected_Pending() {
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
}
private void statusConnected_NotPending() {
assertTrue(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
}
private boolean tryFinish() throws IOException {
/*
* the result of finish will be asserted in multi-thread tests.
*/
boolean connected = false;
assertTrue(this.channel1.isOpen());
try {
connected = this.channel1.finishConnect();
} catch (SocketException e) {
// Finish connection failed, probably due to reset by peer error.
}
if (connected) {
statusConnected_NotPending();
}
return connected;
}
// -------------------------------------------------------------------
// Original tests. Test method for CFII with real data.
// -------------------------------------------------------------------
/**
*
* 'SocketChannelImpl.connect(SocketAddress)'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
)
*/
public void testCFII_Data_ConnectWithServer() throws Exception {
ensureServerOpen();
java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
.allocate(CAPACITY_NORMAL);
java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
this.channel1.connect(localAddr1);
assertTrue(this.channel1.isBlocking());
assertTrue(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
this.channel1.configureBlocking(false);
try {
this.channel1.connect(localAddr1);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// correct
}
assertFalse(this.channel1.isRegistered());
tryFinish();
}
/*
* Test method for 'SocketChannelImpl.connect(SocketAddress)'
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
})
*/
public void testCFII_Data_ConnectWithServer_nonBlocking() throws Exception {
ensureServerOpen();
java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
.allocate(CAPACITY_NORMAL);
java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
this.channel1.configureBlocking(false);
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
assertTrue(tryFinish());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
assertEquals(CAPACITY_NORMAL, this.channel1
.write(writeBufArr, 0, 1));
this.channel1.configureBlocking(false);
try {
this.channel1.connect(localAddr1);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// correct
}
assertFalse(this.channel1.isRegistered());
tryFinish();
}
/*
* Test method for 'SocketChannelImpl.finishConnect()'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
*/
public void testCFII_Data_FinishConnect_nonBlocking() throws IOException {
ensureServerOpen();
java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
.allocate(CAPACITY_NORMAL);
java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
this.channel1.configureBlocking(false);
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// correct
}
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
this.server1.accept();
assertTrue(tryFinish());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
assertEquals(CAPACITY_NORMAL, this.channel1
.write(writeBufArr, 0, 1));
try {
this.channel1.connect(localAddr1);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// correct
}
assertFalse(this.channel1.isRegistered());
tryFinish();
}
/*
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "connect",
args = {java.net.SocketAddress.class}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IOException",
method = "open",
args = {SocketAddress.class}
)
})
*/
public void testCFII_Data_FinishConnect_AddrSetServerStartLater()
throws IOException {
ensureServerClosed();
java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
this.channel1.configureBlocking(false);
try {
SocketChannel.open(localAddr1);
fail("Should throw ConnectException");
} catch (ConnectException e) {
// correct
}
assertTrue(this.channel1.isOpen());
assertFalse(this.channel1.isBlocking());
assertFalse(this.channel1.isConnectionPending());
this.channel1.configureBlocking(true);
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// correct
}
try {
this.channel1.connect(localAddr2);
fail("Should throw ConnectException");
} catch (ConnectException e) {
// correct
}
assertTrue(this.channel1.isBlocking());
try {
this.channel1.finishConnect();
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
assertFalse(this.channel1.isConnected());
// finish after finish OK
assertFalse(this.channel1.isConnectionPending());
this.channel1 = SocketChannel.open();
this.channel1.configureBlocking(false);
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isConnected());
ensureServerOpen();
// cannot connect?
assertFalse(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
try {
this.channel1.connect(localAddr1);
fail("Should throw ConnectionPendingException");
} catch (ConnectionPendingException e) {
// correct
}
this.channel1.configureBlocking(true);
try {
this.channel1.connect(localAddr1);
fail("Should throw ConnectionPendingException");
} catch (ConnectionPendingException e) {
// correct
}
tryFinish();
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
*/
public void testCFII_Data_FinishConnect_ServerStartLater()
throws IOException {
ensureServerClosed();
java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
this.channel1.configureBlocking(true);
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// correct
}
try {
this.channel1.connect(localAddr1);
fail("Should throw ConnectException");
} catch (ConnectException e) {
// correct
}
try {
this.channel1.finishConnect();
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
assertFalse(this.channel1.isConnected());
// finish after finish OK
assertFalse(this.channel1.isConnectionPending());
this.channel1 = SocketChannel.open();
this.channel1.configureBlocking(false);
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isConnected());
ensureServerOpen();
// cannot connect?
assertFalse(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertTrue(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
try {
this.channel1.connect(localAddr1);
fail("Should throw ConnectionPendingException");
} catch (ConnectionPendingException e) {
// correct
}
this.channel1.configureBlocking(true);
try {
this.channel1.connect(localAddr1);
fail("Should throw ConnectionPendingException");
} catch (ConnectionPendingException e) {
// correct
}
tryFinish();
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "finishConnect",
args = {}
)
*/
public void testCFII_Data_FinishConnect_Blocking() throws IOException {
ensureServerOpen();
java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
.allocate(CAPACITY_NORMAL);
java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
this.channel1.configureBlocking(true);
try {
this.channel1.finishConnect();
fail("Should throw NoConnectionPendingException");
} catch (NoConnectionPendingException e) {
// correct
}
this.channel1.connect(localAddr1);
assertTrue(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
assertTrue(tryFinish());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
assertEquals(CAPACITY_NORMAL, this.channel1
.write(writeBufArr, 0, 1));
try {
this.channel1.connect(localAddr1);
fail("Should throw AlreadyConnectedException");
} catch (AlreadyConnectedException e) {
// correct
}
assertFalse(this.channel1.isRegistered());
tryFinish();
}
/**
* Regression test for Harmony-1947.
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify exceptions.",
method = "finishConnect",
args = {}
)
*/
public void test_finishConnect() throws Exception {
SocketAddress address = new InetSocketAddress("localhost", 2046);
ServerSocketChannel theServerChannel = ServerSocketChannel.open();
ServerSocket serversocket = theServerChannel.socket();
serversocket.setReuseAddress(true);
// Bind the socket
serversocket.bind(address);
boolean doneNonBlockingConnect = false;
// Loop so that we make sure we're definitely testing finishConnect()
while (!doneNonBlockingConnect) {
channel1 = SocketChannel.open();
// Set the SocketChannel to non-blocking so that connect(..) does
// not block
channel1.configureBlocking(false);
boolean connected = channel1.connect(address);
if (!connected) {
// Now set the SocketChannel back to blocking so that
// finishConnect() blocks.
channel1.configureBlocking(true);
doneNonBlockingConnect = channel1.finishConnect();
} else {
fail("Non blocking connect was connected too fast." +
"Could not test finishConnect().");
}
if (doneNonBlockingConnect) {
tryFinish();
} else {
fail("finishConnect() did not finish the connection.");
}
channel1.close();
}
if (!serversocket.isClosed()) {
serversocket.close();
}
}
// -------------------------------------------------------------------
// End of original tests. Test method for CFII with real data.
// -------------------------------------------------------------------
/**
* @tests java.nio.channels.SocketChannel#read(ByteBuffer)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_readLByteBuffer_Blocking() throws IOException {
// initialize write content
byte[] writeContent = new byte[CAPACITY_NORMAL];
for (int i = 0; i < writeContent.length; i++) {
writeContent[i] = (byte) i;
}
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
// use OutputStream.write to send CAPACITY_NORMAL bytes data
OutputStream out = acceptedSocket.getOutputStream();
out.write(writeContent);
// use close to guarantee all data is sent
acceptedSocket.close();
ByteBuffer readContent = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
int totalCount = 0;
int count = 0;
long startTime = System.currentTimeMillis();
// use SocketChannel.read to read data
while (totalCount <= CAPACITY_NORMAL) {
count = channel1.read(readContent);
if (EOF == count) {
break;
}
totalCount += count;
// if the channel could not finish reading in TIMEOUT ms, the
// test fails. It is used to guarantee the test never hangs even
// if there are bugs of SocketChannel implementation. For
// blocking read, it possibly returns 0 in some cases.
assertTimeout(startTime, TIMEOUT);
}
// assert read content
assertEquals(CAPACITY_NORMAL, totalCount);
assertEquals(CAPACITY_NORMAL, readContent.position());
readContent.flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContent[i], readContent.get());
}
}
/**
* @tests java.nio.channels.SocketChannel#read(ByteBuffer)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_readLByteBuffer_Nonblocking() throws IOException {
// initialize write content
byte[] writeContent = new byte[CAPACITY_NORMAL];
for (int i = 0; i < writeContent.length; i++) {
writeContent[i] = (byte) i;
}
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
// use OutputStream.write to write CAPACITY_NORMAL bytes data.
OutputStream out = acceptedSocket.getOutputStream();
out.write(writeContent);
// use close to guarantee all data is sent
acceptedSocket.close();
channel1.configureBlocking(false);
ByteBuffer readContent = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
int totalCount = 0;
int count = 0;
long startTime = System.currentTimeMillis();
// use SocketChannel.read to read data
while (totalCount <= CAPACITY_NORMAL) {
count = channel1.read(readContent);
if (EOF == count) {
break;
}
totalCount += count;
// if the channel could not finish reading in TIMEOUT ms, the
// test fails. It is used to guarantee the test never hangs even
// if there are bugs of SocketChannel implementation.
assertTimeout(startTime, TIMEOUT);
}
// assert read content
assertEquals(CAPACITY_NORMAL, totalCount);
assertEquals(CAPACITY_NORMAL, readContent.position());
readContent.flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContent[i], readContent.get());
}
}
/**
* @tests java.nio.channels.SocketChannel#write(ByteBuffer)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
public void test_writeLjava_nio_ByteBuffer_Blocking() throws IOException {
// initialize write content
ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_NORMAL);
for (int i = 0; i < CAPACITY_NORMAL; i++) {
writeContent.put((byte) i);
}
writeContent.flip();
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
// use SocketChannel.write(ByteBuffer) to write CAPACITY_NORMAL bytes
// data
int writtenCount = channel1.write(writeContent);
// assert written count and ByteBuffer position
assertEquals(CAPACITY_NORMAL, writtenCount);
assertEquals(CAPACITY_NORMAL, writeContent.position());
// use close to guarantee all data is sent
channel1.close();
InputStream in = acceptedSocket.getInputStream();
int totalCount = 0;
int count = 0;
byte[] readContent = new byte[CAPACITY_NORMAL + 1];
// if the channel could not finish reading in TIMEOUT ms, the test
// fails. It is used to guarantee the test never hangs even if there
// are bugs of SocketChannel implementation.
acceptedSocket.setSoTimeout(TIMEOUT);
// use InputStream.read to read data.
while (totalCount <= CAPACITY_NORMAL) {
count = in.read(readContent, totalCount, readContent.length
- totalCount);
if (EOF == count) {
break;
}
totalCount += count;
}
// assert read content
assertEquals(CAPACITY_NORMAL, totalCount);
writeContent.flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContent.get(), readContent[i]);
}
}
/**
* @tests java.nio.channels.SocketChannel#write(ByteBuffer)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
public void test_writeLjava_nio_ByteBuffer_NonBlocking() throws Exception {
// initialize write content
ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_NORMAL);
for (int i = 0; i < CAPACITY_NORMAL; i++) {
writeContent.put((byte) i);
}
writeContent.flip();
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
channel1.configureBlocking(false);
int writtenTotalCount = 0;
int writtenCount = 0;
long startTime = System.currentTimeMillis();
// use SocketChannel.write(ByteBuffer) to write CAPACITY_NORMAL bytes
while (writtenTotalCount < CAPACITY_NORMAL) {
writtenCount = channel1.write(writeContent);
writtenTotalCount += writtenCount;
// if the channel could not finish writing in TIMEOUT ms, the
// test fails. It is used to guarantee the test never hangs even
// if there are bugs of SocketChannel implementation.
assertTimeout(startTime, TIMEOUT);
}
// assert written count and ByteBuffer position
assertEquals(CAPACITY_NORMAL, writtenTotalCount);
assertEquals(CAPACITY_NORMAL, writeContent.position());
// use close to guarantee all data is sent
channel1.close();
InputStream in = acceptedSocket.getInputStream();
byte[] readContent = new byte[CAPACITY_NORMAL + 1];
int totalCount = 0;
int count = 0;
// if the channel could not finish reading in TIMEOUT ms, the test
// fails. It is used to guarantee the test never hangs even if there
// are bugs of SocketChannel implementation.
acceptedSocket.setSoTimeout(TIMEOUT);
// use InputStream.read to read data.
while (totalCount <= CAPACITY_NORMAL) {
count = in.read(readContent, totalCount, readContent.length
- totalCount);
if (EOF == count) {
break;
}
totalCount += count;
}
// assert read content
assertEquals(CAPACITY_NORMAL, totalCount);
writeContent.flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContent.get(), readContent[i]);
}
}
/**
* @tests java.nio.channels.SocketChannel#read(ByteBuffer)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
@BrokenTest("Occasionally fail in CTS, but works in CoreTestRunner")
public void test_writeLjava_nio_ByteBuffer_Nonblocking_HugeData() throws IOException {
// initialize write content
ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_HUGE);
for (int i = 0; i < CAPACITY_HUGE; i++) {
writeContent.put((byte) i);
}
writeContent.flip();
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
channel1.configureBlocking(false);
int writtenTotalCount = 0;
int writtenCount = 1;
long startTime = System.currentTimeMillis();
// use SocketChannel.write(ByteBuffer) to try to write CAPACITY_HUGE bytes
while (writtenTotalCount < CAPACITY_HUGE && writtenCount > 0) {
writtenCount = channel1.write(writeContent);
if (writtenCount == 0 && writtenTotalCount < CAPACITY_HUGE) {
assertEquals(0, channel1.write(writeContent));
break;
}
writtenTotalCount += writtenCount;
// if the channel could not finish writing in TIMEOUT ms, the
// test fails. It is used to guarantee the test never hangs even
// if there are bugs of SocketChannel implementation.
assertTimeout(startTime, TIMEOUT);
}
}
/*
* Fails if the difference between current time and start time is greater
* than timeout.
*/
private void assertTimeout(long startTime, long timeout) {
long currentTime = System.currentTimeMillis();
if ((currentTime - startTime) > timeout) {
fail("Timeout");
}
}
// -------------------------------------------------
// Test for read/write but no real data expressed
// -------------------------------------------------
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies ClosedChannelException",
method = "read",
args = {java.nio.ByteBuffer.class}
)
*/
public void testReadByteBuffer() throws Exception {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer readBuf = java.nio.ByteBuffer
.allocate(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
// note: blocking-mode will make the read process endless!
this.channel1.configureBlocking(false);
try {
channel1.read(readBuf);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isBlocking());
assertTrue(this.channel1.isConnectionPending());
assertFalse(this.channel1.isConnected());
assertTrue(tryFinish());
assertEquals(0, this.channel1.read(readBuf));
this.channel1.close();
try {
channel1.read(readBuf);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies ClosedChannelException",
method = "read",
args = {java.nio.ByteBuffer.class}
)
*/
public void testReadByteBuffer_Direct() throws Exception {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer readBuf = java.nio.ByteBuffer
.allocateDirect(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
// note: blocking-mode will make the read process endless!
this.channel1.configureBlocking(false);
try {
channel1.read(readBuf);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isBlocking());
assertTrue(this.channel1.isConnectionPending());
assertFalse(this.channel1.isConnected());
assertTrue(tryFinish());
assertEquals(0, this.channel1.read(readBuf));
this.channel1.close();
try {
channel1.read(readBuf);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer.class}
)
*/
public void testReadByteBuffer_BufNull() throws Exception {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer readBuf = java.nio.ByteBuffer.allocate(0);
// note: blocking-mode will make the read process endless!
this.channel1.configureBlocking(false);
try {
channel1.read((java.nio.ByteBuffer) null);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
this.channel1.connect(localAddr1);
assertTrue(tryFinish());
try {
this.channel1.read((java.nio.ByteBuffer) null);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
assertEquals(0, this.channel1.read(readBuf));
}
/*
* SocketChannelImpl.read(ByteBuffer[], int, int)'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testReadByteBufferArrayIntInt() throws Exception {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
readBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
readBuf[1] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
// note: blocking-mode will make the read process endless!
this.channel1.configureBlocking(false);
try {
channel1.read(readBuf, 0, 1);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isBlocking());
assertTrue(this.channel1.isConnectionPending());
assertFalse(this.channel1.isConnected());
assertTrue(tryFinish());
assertEquals(0, this.channel1.read(readBuf, 0, 1));
assertEquals(0, this.channel1.read(readBuf, 0, 2));
this.channel1.close();
try {
channel1.read(readBuf, 0, 1);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
* SocketChannelImpl.read(ByteBuffer[], int, int)'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testReadByteBufferArrayIntInt_Direct() throws Exception {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
readBuf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
readBuf[1] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
// note: blocking-mode will make the read process endless!
this.channel1.configureBlocking(false);
try {
channel1.read(readBuf, 0, 1);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertFalse(this.channel1.isBlocking());
assertTrue(this.channel1.isConnectionPending());
assertFalse(this.channel1.isConnected());
assertTrue(tryFinish());
assertEquals(0, this.channel1.read(readBuf, 0, 1));
assertEquals(0, this.channel1.read(readBuf, 0, 2));
this.channel1.close();
try {
channel1.read(readBuf, 0, 1);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testReadByteBufferArrayIntInt_BufNull() throws Exception {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
readBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
// note: blocking-mode will make the read process endless!
this.channel1.configureBlocking(false);
try {
channel1.read(null, 0, 0);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
this.channel1.connect(localAddr1);
assertTrue(tryFinish());
try {
channel1.read(null, 0, 0);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
try {
channel1.read(readBuf, 0, 2);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
assertEquals(0, this.channel1.read(readBuf, 0, 1));
this.channel1.close();
try {
channel1.read(null, 0, 1);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
public void testWriteByteBuffer() throws IOException {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
.allocate(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
try {
channel1.write(writeBuf);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertTrue(this.channel1.isBlocking());
assertTrue(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
this.channel1.close();
try {
channel1.write(writeBuf);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify AsynchronousCloseException, ClosedByInterruptException.",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
public void testWriteByteBuffer_Direct() throws IOException {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
.allocateDirect(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
try {
channel1.write(writeBuf);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertTrue(this.channel1.isBlocking());
assertTrue(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
this.channel1.close();
try {
channel1.write(writeBuf);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
public void testWriteByteBuffer_BufNull() throws IOException {
assertTrue(this.server1.isBound());
java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer.allocate(0);
this.channel1.connect(localAddr1);
assertEquals(this.channel1.write(writeBuf), 0);
try {
this.channel1.write((java.nio.ByteBuffer) null);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
}
/*
* SocketChannelImpl.write(ByteBuffer[], int, int)'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify AsynchronousCloseException," +
"ClosedByInterruptException.",
method = "write",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testWriteByteBufferArrayIntInt() throws IOException {
java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[2];
writeBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
writeBuf[1] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
try {
channel1.write(writeBuf, 0, 1);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertTrue(this.channel1.isBlocking());
assertTrue(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 1));
// still writes the same size as above
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 2));
writeBuf[0].flip();
writeBuf[1].flip();
assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
this.channel1.close();
try {
channel1.write(writeBuf, 0, 1);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
* SocketChannelImpl.write(ByteBuffer[], int, int)'
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testWriteByteBufferArrayIntInt_Direct() throws IOException {
java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[2];
writeBuf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
writeBuf[1] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
assertFalse(this.channel1.isRegistered());
assertTrue(this.channel1.isBlocking());
assertFalse(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
try {
channel1.write(writeBuf, 0, 1);
fail("Should throw NotYetConnectedException");
} catch (NotYetConnectedException e) {
// correct
}
this.channel1.connect(localAddr1);
assertTrue(this.channel1.isBlocking());
assertTrue(this.channel1.isConnected());
assertFalse(this.channel1.isConnectionPending());
assertTrue(this.channel1.isOpen());
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 1));
// still writes the same size as above
assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf, 0, 2));
writeBuf[0].flip();
writeBuf[1].flip();
assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
this.channel1.close();
try {
channel1.write(writeBuf, 0 ,1);
fail("Should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testWriteByteBufferArrayIntInt_BufNull() throws IOException {
java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[0];
this.channel1.connect(localAddr1);
try {
this.channel1.write(null, 0, 1);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
assertEquals(0, this.channel1.write(writeBuf, 0, 0));
try {
this.channel1.write(writeBuf, 0, 1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
writeBuf = new java.nio.ByteBuffer[1];
try {
this.channel1.write(writeBuf, 0, 1);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
writeBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
try {
this.channel1.write(writeBuf, 0, 2);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
this.server1.close();
try {
channel1.read(null, 0, 1);
fail("Should throw NPE");
} catch (NullPointerException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IndexOutOfBoundsException.",
method = "write",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testWriteByteBufferArrayIntInt_SizeError() throws IOException {
java.nio.ByteBuffer[] writeBuf =
{java.nio.ByteBuffer.allocate(CAPACITY_NORMAL)};
this.channel1.connect(localAddr1);
try {
this.channel1.write(writeBuf, -1, 1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
assertEquals(0, this.channel1.write(writeBuf, 0, 0));
try {
this.channel1.write(writeBuf, 0, -1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
try {
this.channel1.write(writeBuf, 1, 1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
try {
this.channel1.write(writeBuf, 0, 2);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
}
/*
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void testReadByteBufferArrayIntInt_SizeError() throws IOException {
java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[0];
this.channel1.connect(localAddr1);
try {
this.channel1.read(null, -1, 1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
assertEquals(0, this.channel1.read(readBuf, 0, 0));
try {
this.channel1.read(readBuf, 0, -1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
readBuf = new java.nio.ByteBuffer[1];
try {
this.channel1.read(readBuf, 2, 1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
try {
this.channel1.read(readBuf, 2, -1);
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
this.server1.close();
try {
assertEquals(CAPACITY_NORMAL, this.channel1.read(null, -1, -1));
fail("Should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// correct
}
}
/*
* ==========================================================================
* Tests for read/write real data
* ==========================================================================
*/
/**
* @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_read$LByteBuffer_blocking() throws Exception {
assert_read$LByteBuffer(true);
}
/**
* @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_read$LByteBuffer_nonblocking() throws Exception {
assert_read$LByteBuffer(false);
}
private void assert_read$LByteBuffer(boolean isBlocking) throws IOException {
// initialize write content
byte[] writeContent = new byte[CAPACITY_NORMAL * 2];
for (int i = 0; i < CAPACITY_NORMAL * 2; i++) {
writeContent[i] = (byte) i;
}
ByteBuffer[] readContents = new ByteBuffer[2];
readContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
readContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
// use OutputStream.write to send CAPACITY_NORMAL * 2 bytes data
OutputStream out = acceptedSocket.getOutputStream();
out.write(writeContent);
// use close to guarantee all data is sent
acceptedSocket.close();
// configure block/nonblock mode
channel1.configureBlocking(isBlocking);
long startTime = System.currentTimeMillis();
long totalRead = 0;
long countRead = 0;
while (totalRead <= CAPACITY_NORMAL * 2) {
countRead = channel1.read(readContents);
if (0 == countRead && !readContents[1].hasRemaining()) {
// read returns 0 because readContents is full
break;
}
if (EOF == countRead) {
break;
}
totalRead += countRead;
// if the channel could not finish reading in TIMEOUT ms, the
// test fails. It is used to guarantee the test never hangs even
// if there are bugs of SocketChannel implementation. For
// blocking read, it possibly returns 0 in some cases.
assertTimeout(startTime, TIMEOUT);
}
// assert total bytes read and the position of ByteBuffers
assertEquals(CAPACITY_NORMAL * 2, totalRead);
assertEquals(CAPACITY_NORMAL, readContents[0].position());
assertEquals(CAPACITY_NORMAL, readContents[1].position());
// assert read content
readContents[0].flip();
readContents[1].flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContent[i], readContents[0].get());
}
for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
assertEquals(writeContent[i], readContents[1].get());
}
}
/**
* @tests java.nio.channels.SocketChannel#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_blocking() throws Exception {
assert_read$LByteBufferII(true);
}
/**
* @tests java.nio.channels.SocketChannel#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_nonblocking() throws Exception {
assert_read$LByteBufferII(false);
}
private void assert_read$LByteBufferII(boolean isBlocking) throws IOException {
// initialize write content
byte[] writeContent = new byte[CAPACITY_NORMAL * 2];
for (int i = 0; i < CAPACITY_NORMAL * 2; i++) {
writeContent[i] = (byte) i;
}
ByteBuffer[] readContents = new ByteBuffer[2];
readContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
readContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
// use OutputStream.write to send CAPACITY_NORMAL * 2 bytes data
OutputStream out = acceptedSocket.getOutputStream();
out.write(writeContent);
// use close to guarantee all data is sent
acceptedSocket.close();
// configure block/nonblock mode
channel1.configureBlocking(isBlocking);
long startTime = System.currentTimeMillis();
long totalRead = 0;
long countRead = 0;
while (totalRead <= CAPACITY_NORMAL * 2) {
countRead = channel1.read(readContents, 0, 2);
if (0 == countRead && !readContents[1].hasRemaining()) {
// read returns 0 because readContents is full
break;
}
if (EOF == countRead) {
break;
}
totalRead += countRead;
// if the channel could not finish reading in TIMEOUT ms, the
// test fails. It is used to guarantee the test never hangs even
// if there are bugs of SocketChannel implementation. For
// blocking read, it possibly returns 0 in some cases.
assertTimeout(startTime, TIMEOUT);
}
// assert total bytes read and the position of ByteBuffers
assertEquals(CAPACITY_NORMAL * 2, totalRead);
assertEquals(CAPACITY_NORMAL, readContents[0].position());
assertEquals(CAPACITY_NORMAL, readContents[1].position());
// assert read content
readContents[0].flip();
readContents[1].flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContent[i], readContents[0].get());
}
for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
assertEquals(writeContent[i], readContents[1].get());
}
}
/**
* @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_write$LByteBuffer_blocking() throws Exception {
assert_write$LByteBuffer(true);
}
/**
* @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_write$LByteBuffer_nonblocking() throws Exception {
assert_write$LByteBuffer(false);
}
private void assert_write$LByteBuffer(boolean isBlocking)
throws IOException {
// initialize write contents
ByteBuffer writeContents[] = new ByteBuffer[2];
writeContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
writeContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL);
for (int i = 0; i < CAPACITY_NORMAL; i++) {
writeContents[0].put((byte) i);
}
for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
writeContents[1].put((byte) i);
}
writeContents[0].flip();
writeContents[1].flip();
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
// set blocking/nonblocking mode
channel1.configureBlocking(isBlocking);
assertEquals(2 * CAPACITY_NORMAL, channel1.write(writeContents));
// assert written count and ByteBuffer position
assertEquals(CAPACITY_NORMAL, writeContents[0].position());
assertEquals(CAPACITY_NORMAL, writeContents[1].position());
// use close to guarantee all data is sent
channel1.close();
InputStream in = acceptedSocket.getInputStream();
byte[] readContent = new byte[CAPACITY_NORMAL * 2 + 1];
int totalCount = 0;
int count = 0;
// if the channel could not finish reading in TIMEOUT ms, the test
// fails. It is used to guarantee the test never hangs even if there
// are bugs of SocketChannel implementation.
acceptedSocket.setSoTimeout(TIMEOUT);
// use InputStream.read to read data.
while (totalCount <= CAPACITY_NORMAL) {
count = in.read(readContent, totalCount, readContent.length
- totalCount);
if (EOF == count) {
break;
}
totalCount += count;
}
// assert read content
assertEquals(CAPACITY_NORMAL * 2, totalCount);
writeContents[0].flip();
writeContents[1].flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContents[0].get(), readContent[i]);
}
for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
assertEquals(writeContents[1].get(), readContent[i]);
}
}
/**
* @tests java.nio.channels.SocketChannel#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_blocking() throws Exception {
assert_write$LByteBufferII(true);
}
/**
* @tests java.nio.channels.SocketChannel#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_nonblocking() throws Exception {
assert_write$LByteBufferII(false);
}
private void assert_write$LByteBufferII(boolean isBlocking)
throws IOException {
// initialize write contents
ByteBuffer writeContents[] = new ByteBuffer[2];
writeContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
writeContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL);
for (int i = 0; i < CAPACITY_NORMAL; i++) {
writeContents[0].put((byte) i);
}
for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
writeContents[1].put((byte) i);
}
writeContents[0].flip();
writeContents[1].flip();
// establish connection
channel1.connect(localAddr1);
Socket acceptedSocket = server1.accept();
// set blocking/nonblocking mode
channel1.configureBlocking(isBlocking);
assertEquals(CAPACITY_NORMAL, channel1.write(writeContents, 0, 1));
assertEquals(CAPACITY_NORMAL, channel1.write(writeContents, 1, 1));
// assert written count and ByteBuffer position
assertEquals(CAPACITY_NORMAL, writeContents[0].position());
assertEquals(CAPACITY_NORMAL, writeContents[1].position());
// use close to guarantee all data is sent
channel1.close();
InputStream in = acceptedSocket.getInputStream();
byte[] readContent = new byte[CAPACITY_NORMAL * 2 + 1];
int totalCount = 0;
int count = 0;
// if the channel could not finish reading in TIMEOUT ms, the test
// fails. It is used to guarantee the test never hangs even if there
// are bugs of SocketChannel implementation.
acceptedSocket.setSoTimeout(TIMEOUT);
// use InputStream.read to read data.
while (totalCount <= CAPACITY_NORMAL) {
count = in.read(readContent, totalCount, readContent.length
- totalCount);
if (EOF == count) {
break;
}
totalCount += count;
}
// assert read content
assertEquals(CAPACITY_NORMAL * 2, totalCount);
writeContents[0].flip();
writeContents[1].flip();
for (int i = 0; i < CAPACITY_NORMAL; i++) {
assertEquals(writeContents[0].get(), readContent[i]);
}
for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
assertEquals(writeContents[1].get(), readContent[i]);
}
}
/*
@TestTargets({
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
),
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
clazz = SelectableChannel.class,
method = "configureBlocking",
args = {boolean.class}
)
})
*/
public void testSocket_configureblocking() throws IOException {
byte[] serverWBuf = new byte[CAPACITY_NORMAL];
for (int i = 0; i < serverWBuf.length; i++) {
serverWBuf[i] = (byte) i;
}
java.nio.ByteBuffer buf = java.nio.ByteBuffer
.allocate(CAPACITY_NORMAL + 1);
channel1.connect(localAddr1);
server1.accept();
Socket sock = this.channel1.socket();
channel1.configureBlocking(false);
assertFalse(channel1.isBlocking());
OutputStream channelSocketOut = sock.getOutputStream();
try {
// write operation is not allowed in non-blocking mode
channelSocketOut.write(buf.array());
fail("Non-Blocking mode should cause IllegalBlockingModeException");
} catch (IllegalBlockingModeException e) {
// correct
}
channel1.configureBlocking(true);
assertTrue(channel1.isBlocking());
// write operation is allowed in blocking mode
channelSocketOut.write(buf.array());
}
/**
* @tests SocketChannel#read(ByteBuffer[], int, int) when remote server
* closed
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void test_socketChannel_read_ByteBufferII_remoteClosed()
throws Exception {
// regression 1 for HARMONY-549
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(localAddr2);
SocketChannel sc = SocketChannel.open();
sc.connect(localAddr2);
ssc.accept().close();
ByteBuffer[] buf = {ByteBuffer.allocate(10)};
assertEquals(-1, sc.read(buf, 0, 1));
ssc.close();
sc.close();
}
/**
* @tests SocketChannel#write(ByteBuffer[], int, int)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void test_socketChannel_write_ByteBufferII() throws Exception {
// regression 2 for HARMONY-549
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(localAddr2);
SocketChannel sc = SocketChannel.open();
sc.connect(localAddr2);
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));
}
/**
* @tests SocketChannel#read(ByteBuffer[], int, int) with a null ByteBuffer
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class, int.class, int.class}
)
*/
public void test_socketChannel_read_ByteBufferII_bufNULL() throws Exception {
// regression 3 for HARMONY-549
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(localAddr2);
SocketChannel sc = SocketChannel.open();
sc.connect(localAddr2);
ssc.accept();
ByteBuffer[] buf = new ByteBuffer[2];
buf[0] = ByteBuffer.allocate(1);
// let buf[1] be null
try {
sc.read(buf, 0, 2);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
ssc.close();
sc.close();
}
/**
* @tests SocketChannel#write(ByteBuffer) after close
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
public void test_socketChannel_write_close() throws Exception {
// regression 4 for HARMONY-549
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(localAddr2);
SocketChannel sc = SocketChannel.open();
sc.connect(localAddr2);
SocketChannel sock = ssc.accept();
ByteBuffer buf = null;
ssc.close();
sc.close();
try {
sc.write(buf);
fail("should throw NPE");
} catch (NullPointerException e) {
// expected
}
sock.close();
}
/**
* @tests SocketChannel#write(ByteBuffer) if position is not zero
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "write",
args = {java.nio.ByteBuffer.class}
)
*/
public void test_socketChannel_write_ByteBuffer_posNotZero()
throws Exception {
// regression 5 for HARMONY-549
final String testStr = "Hello World";
ByteBuffer readBuf = ByteBuffer.allocate(11);
ByteBuffer buf = ByteBuffer.wrap(testStr.getBytes());
ServerSocketChannel ssc = ServerSocketChannel.open();
ssc.socket().bind(localAddr2);
SocketChannel sc = SocketChannel.open();
sc.connect(localAddr2);
buf.position(2);
ssc.accept().write(buf);
assertEquals(9, sc.read(readBuf));
buf.flip();
readBuf.flip();
byte[] read = new byte[9];
byte[] write = new byte[11];
buf.get(write);
readBuf.get(read);
for (int i = 0; i < 9; i++) {
assertEquals(read[i], write[i + 2]);
}
}
/**
* @tests SocketChannelImpl#read(ByteBuffer[])
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Doesn't verify exceptions.",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_read$LByteBuffer_Blocking() throws IOException {
// regression test for Harmony-728
byte[] data = new byte[CAPACITY_NORMAL];
for (int i = 0; i < CAPACITY_NORMAL; i++) {
data[i] = (byte) i;
}
ByteBuffer[] buf = new ByteBuffer[2];
buf[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
buf[1] = ByteBuffer.allocate(CAPACITY_NORMAL);
channel1.connect(localAddr1);
Socket socket = null;
try {
socket = server1.accept();
OutputStream out = socket.getOutputStream();
out.write(data);
// should not block here
channel1.read(buf);
} finally {
if (null != socket) {
socket.close();
} else {
fail();
}
}
}
/**
* @tests SocketChannelImpl#socket().getOutputStream().read
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies IllegalBlockingModeException, NullPointerException.",
method = "socket",
args = {}
)
*/
public void test_socket_getOutputStream_nonBlocking_read_Exception()
throws IOException {
channel1.connect(this.localAddr1);
InputStream is = channel1.socket().getInputStream();
channel1.configureBlocking(false);
try {
is.read();
fail("should throw IllegalBlockingModeException");
} catch (IllegalBlockingModeException e) {
// expected
}
try {
is.read(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
is.read(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
// closed
is.close();
try {
is.read(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
is.read();
fail("should throw IllegalBlockingModeException");
} catch (IllegalBlockingModeException e) {
// expected
}
try {
is.read(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
is.read(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
}
/**
* @tests SocketChannelImpl#socket().getOutputStream().read
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException, ClosedChannelException, IndexOutOfBoundsException.",
method = "socket",
args = {}
)
*/
public void test_socket_getOutputStream_blocking_read_Exception()
throws IOException {
channel1.connect(this.localAddr1);
InputStream is = channel1.socket().getInputStream();
try {
is.read(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
is.read(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
is.read(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
// closed
is.close();
try {
is.read(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
is.read();
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
try {
is.read(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
is.read(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
}
/**
* @tests SocketChannelImpl#socket().getOutputStream().write
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException, IllegalBlockingModeException.",
method = "socket",
args = {}
)
*/
public void test_socket_getOutputStream_nonBlocking_write_Exception()
throws IOException {
channel1.connect(this.localAddr1);
OutputStream os = channel1.socket().getOutputStream();
channel1.configureBlocking(false);
try {
os.write(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(1);
fail("should throw IllegalBlockingModeException");
} catch (IllegalBlockingModeException e) {
// expected
}
try {
os.write(1);
fail("should throw IllegalBlockingModeException");
} catch (IllegalBlockingModeException e) {
// expected
}
try {
os.write(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
// closed
os.close();
try {
os.write(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(1);
fail("should throw IllegalBlockingModeException");
} catch (IllegalBlockingModeException e) {
// expected
}
try {
os.write(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
}
/**
* @tests SocketChannelImpl#socket().getOutputStream().write
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "Verifies NullPointerException, IndexOutOfBoundsException, ClosedChannelException.",
method = "socket",
args = {}
)
*/
public void test_socket_getOutputStream_blocking_write_Exception()
throws IOException {
channel1.connect(this.localAddr1);
OutputStream os = channel1.socket().getOutputStream();
try {
os.write(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
// closed
os.close();
try {
os.write(null);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(1);
fail("should throw ClosedChannelException");
} catch (ClosedChannelException e) {
// expected
}
try {
os.write(null, 1, 1);
fail("should throw NullPointerException");
} catch (NullPointerException e) {
// expected
}
try {
os.write(null, -1, 1);
fail("should throw IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
// expected
}
}
/**
* @tests SocketChannelImpl#socket().getOutputStream().write(int)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "socket",
args = {}
)
*/
public void test_socket_getOutputStream_write_oneByte()
throws IOException {
// Regression test for Harmony-3475
int MAGIC = 123;
channel1.connect(this.localAddr1);
OutputStream os = channel1.socket().getOutputStream();
Socket acceptedSocket = server1.accept();
InputStream in = acceptedSocket.getInputStream();
os.write(MAGIC);
channel1.close();
int lastByte = in.read();
if (lastByte == -1) {
fail("Server received nothing. Expected 1 byte.");
} else if (lastByte != MAGIC) {
fail("Server received wrong single byte: " + lastByte
+ ", expected: " + MAGIC);
}
lastByte = in.read();
if (lastByte != -1) {
fail("Server received too long sequence. Expected 1 byte.");
}
}
/**
* @throws IOException
* @tests java.nio.channels.SocketChannel#read(ByteBuffer)
@TestTargetNew(
level = TestLevel.PARTIAL_COMPLETE,
notes = "",
method = "read",
args = {java.nio.ByteBuffer[].class}
)
*/
public void test_socketChannel_read_DirectByteBuffer() throws InterruptedException, IOException {
ServerThread server = new ServerThread();
server.start();
Thread.currentThread().sleep(1000);
InetSocketAddress address = new InetSocketAddress(InetAddress
.getByName("localhost"), port);
// First test with array based byte buffer
SocketChannel sc = SocketChannel.open();
sc.connect(address);
ByteBuffer buf = ByteBuffer.allocate(data.length);
buf.limit(data.length / 2);
sc.read(buf);
buf.limit(buf.capacity());
sc.read(buf);
sc.close();
// Make sure the buffer is filled correctly
buf.rewind();
assertSameContent(data, buf);
// Now test with direct byte buffer
sc = SocketChannel.open();
sc.connect(address);
buf = ByteBuffer.allocateDirect(data.length);
buf.limit(data.length / 2);
sc.read(buf);
buf.limit(buf.capacity());
sc.read(buf);
sc.close();
// Make sure the buffer is filled correctly
buf.rewind();
assertSameContent(data, buf);
}
private void assertSameContent(byte[] data, ByteBuffer buf) {
for (byte b : data) {
if (b != buf.get()) {
int pos = buf.position() - 1;
fail("Content not equal. Buffer position: " +
(pos) + " expected: " + b + " was: " + buf.get(pos));
}
}
}
public static boolean done = false;
public static int port = Support_PortManager.getNextPort();
public static byte[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
static class ServerThread extends Thread {
@Override
public void run() {
try {
ServerSocketChannel ssc = ServerSocketChannel.open();
InetSocketAddress addr = new InetSocketAddress(InetAddress
.getByAddress(new byte[] {0, 0, 0, 0}), port);
ssc.socket().bind(addr, 0);
ByteBuffer buf = ByteBuffer.allocate(10);
buf.put(data);
while (!done) {
SocketChannel sc = ssc.accept();
buf.rewind();
sc.write(buf);
}
} catch (Exception e) {
// ignore
}
}
}
class MockSocketChannel extends SocketChannel {
private boolean isWriteCalled = false;
private boolean isReadCalled = false;
private boolean isConstructorCalled = false;
public MockSocketChannel(SelectorProvider provider) {
super(provider);
isConstructorCalled = true;
}
public Socket socket() {
return null;
}
public boolean isConnected() {
return false;
}
public boolean isConnectionPending() {
return false;
}
public boolean connect(SocketAddress address) throws IOException {
return false;
}
public boolean finishConnect() throws IOException {
return false;
}
public int read(ByteBuffer target) throws IOException {
return 0;
}
public long read(ByteBuffer[] targets, int offset, int length)
throws IOException {
// Verify that calling read(ByteBuffer[]) leads to the method
// read(ByteBuffer[], int, int) being called with a 0 for the
// second parameter and targets.length as the third parameter.
if (0 == offset && length == targets.length) {
isReadCalled = true;
}
return 0;
}
public int write(ByteBuffer source) throws IOException {
return 0;
}
public long write(ByteBuffer[] sources, int offset, int length)
throws IOException {
// Verify that calling write(ByteBuffer[]) leads to the method
// write(ByteBuffer[], int, int) being called with a 0 for the
// second parameter and sources.length as the third parameter.
if (0 == offset && length == sources.length) {
isWriteCalled = true;
}
return 0;
}
protected void implCloseSelectableChannel() throws IOException {
// empty
}
protected void implConfigureBlocking(boolean blockingMode)
throws IOException {
// empty
}
}
class SubSocketAddress extends SocketAddress {
private static final long serialVersionUID = 1L;
// empty
public SubSocketAddress() {
super();
}
}
}