/**
* Normally I would not separate out one class for testing, but when this is integrated with the
* ChanMgr, testing becomes non-deterministic with packets being separated and such. This allows
* more deterministic testing to fully test AsynchSSLEngine.
*
* @author dean.hiller
*/
public class TestNewAsynchSSLEngine2 extends TestCase {
private static final Logger log = Logger.getLogger(TestNewAsynchSSLEngine2.class.getName());
private BufferHelper helper = ChannelServiceFactory.bufferHelper(null);
private MockObject serverList = MockObjectFactory.createMock(SSLListener.class);
private MockObject clientList = MockObjectFactory.createMock(SSLListener.class);
private AsyncSSLEngine serverEngine;
private AsyncSSLEngine clientEngine;
@Override
protected void setUp() throws Exception {
HandlerForTests.setupLogging();
serverList.setDefaultBehavior("packetEncrypted", new CloneByteBuffer());
clientList.setDefaultBehavior("packetEncrypted", new CloneByteBuffer());
SSLEngineFactory sslEngineFactory = new MockSSLEngineFactory();
FactoryCreator creator = FactoryCreator.createFactory(null);
SSLEngine wrappedSvr = sslEngineFactory.createEngineForServerSocket();
serverEngine = creator.createSSLEngine("[serverAsynch] ", wrappedSvr, null);
serverEngine.setListener((SSLListener) serverList);
SSLEngine wrappedClient = sslEngineFactory.createEngineForSocket();
clientEngine = creator.createSSLEngine("[clientEngine] ", wrappedClient, null);
clientEngine.setListener((SSLListener) clientList);
}
@Override
protected void tearDown() throws Exception {
if (!clientEngine.isClosed()) closeWithExpects(clientEngine, clientList);
if (!serverEngine.isClosed()) closeWithExpects(serverEngine, serverList);
HandlerForTests.checkForWarnings();
clientList.expect(MockObject.NONE);
serverList.expect(MockObject.NONE);
}
private void closeWithExpects(AsyncSSLEngine engine, MockObject sslListener) throws IOException {
TestNewAsynchSSLEngine.closeWithExpects(engine, sslListener);
// engine.close();
//
// String[] methodNames = new String[2];
// methodNames[0] = "packetEncrypted";
// methodNames[1] = "closed";
// sslListener.expect(methodNames);
}
/**
* This tests the Runnable task being run in between packets such that it should not cause packet
* feeds to create new Runnables, and can run before all packets are in.
*/
public void testDelayedRunTask() throws Exception {
log.fine("B*******************************************");
clientEngine.beginHandshake();
CalledMethod m = clientList.expect("packetEncrypted");
ByteBuffer b = (ByteBuffer) m.getAllParams()[0];
serverEngine.feedEncryptedPacket(b, null);
m = serverList.expect("runTask");
Runnable r = (Runnable) m.getAllParams()[0];
r.run();
m = serverList.expect("packetEncrypted");
b = (ByteBuffer) m.getAllParams()[0];
clientEngine.feedEncryptedPacket(b, null);
m = clientList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
String[] methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "packetEncrypted";
CalledMethod[] methods = clientList.expect(methodNames);
ByteBuffer b0 = (ByteBuffer) methods[0].getAllParams()[0];
serverEngine.feedEncryptedPacket(b0, null);
ByteBuffer b1 = (ByteBuffer) methods[1].getAllParams()[0];
m = serverList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
serverEngine.feedEncryptedPacket(b1, null);
ByteBuffer b2 = (ByteBuffer) methods[2].getAllParams()[0];
// THIS IS THE DELAYED RUN TASK run after second feed of data to sslEngine...
r.run();
serverEngine.feedEncryptedPacket(b2, null);
String[] methodNames1 = new String[3];
methodNames1[0] = "packetEncrypted";
methodNames1[1] = "packetEncrypted";
methodNames1[2] = "encryptedLinkEstablished";
CalledMethod[] methods1 = serverList.expect(methodNames1);
ByteBuffer b01 = (ByteBuffer) methods1[0].getAllParams()[0];
clientEngine.feedEncryptedPacket(b01, null);
ByteBuffer b11 = (ByteBuffer) methods1[1].getAllParams()[0];
clientEngine.feedEncryptedPacket(b11, null);
clientList.expect("encryptedLinkEstablished");
log.fine("E*******************************************");
}
/**
* This tests the situation where the Runnable must tell the engine to reprocess the buffer
* itself.
*/
public void testReallyDelayedRunTask() throws Exception {
log.fine("B*******************************************");
clientEngine.beginHandshake();
CalledMethod m = clientList.expect("packetEncrypted");
ByteBuffer b = (ByteBuffer) m.getAllParams()[0];
serverEngine.feedEncryptedPacket(b, null);
m = serverList.expect("runTask");
Runnable r = (Runnable) m.getAllParams()[0];
r.run();
m = serverList.expect("packetEncrypted");
b = (ByteBuffer) m.getAllParams()[0];
clientEngine.feedEncryptedPacket(b, null);
m = clientList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
String[] methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "packetEncrypted";
CalledMethod[] methods = clientList.expect(methodNames);
ByteBuffer b0 = (ByteBuffer) methods[0].getAllParams()[0];
serverEngine.feedEncryptedPacket(b0, null);
ByteBuffer b1 = (ByteBuffer) methods[1].getAllParams()[0];
m = serverList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
serverEngine.feedEncryptedPacket(b1, null);
ByteBuffer b2 = (ByteBuffer) methods[2].getAllParams()[0];
serverEngine.feedEncryptedPacket(b2, null);
String[] methodNames1 = new String[3];
// THIS IS THE REALLY DELAYED RUN TASK run after all 3 packets are fed
// to ssl engine
r.run();
methodNames1[0] = "packetEncrypted";
methodNames1[1] = "packetEncrypted";
methodNames1[2] = "encryptedLinkEstablished";
CalledMethod[] methods1 = serverList.expect(methodNames1);
ByteBuffer b01 = (ByteBuffer) methods1[0].getAllParams()[0];
clientEngine.feedEncryptedPacket(b01, null);
ByteBuffer b11 = (ByteBuffer) methods1[1].getAllParams()[0];
clientEngine.feedEncryptedPacket(b11, null);
clientList.expect("encryptedLinkEstablished");
log.fine("E*******************************************");
}
public void testHalfPackets() throws Exception {
clientEngine.beginHandshake();
CalledMethod m = clientList.expect("packetEncrypted");
ByteBuffer b = (ByteBuffer) m.getAllParams()[0];
feedPacket(serverEngine, b);
m = serverList.expect("runTask");
Runnable r = (Runnable) m.getAllParams()[0];
r.run();
m = serverList.expect("packetEncrypted");
b = (ByteBuffer) m.getAllParams()[0];
log.fine("remain1=" + b.remaining());
feedPacket(clientEngine, b);
m = clientList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
String[] methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "packetEncrypted";
CalledMethod[] methods = clientList.expect(methodNames);
ByteBuffer b0 = (ByteBuffer) methods[0].getAllParams()[0];
feedPacket(serverEngine, b0);
m = serverList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
ByteBuffer b1 = (ByteBuffer) methods[1].getAllParams()[0];
feedPacket(serverEngine, b1);
ByteBuffer b2 = (ByteBuffer) methods[2].getAllParams()[0];
feedPacket(serverEngine, b2);
methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "encryptedLinkEstablished";
methods = serverList.expect(methodNames);
b0 = (ByteBuffer) methods[0].getAllParams()[0];
feedPacket(clientEngine, b0);
b1 = (ByteBuffer) methods[1].getAllParams()[0];
feedPacket(clientEngine, b1);
clientList.expect("encryptedLinkEstablished");
}
public void testCombinedPackets() throws Exception {
clientEngine.beginHandshake();
CalledMethod m;
ByteBuffer b;
CalledMethod m1 = clientList.expect("packetEncrypted");
ByteBuffer b3 = (ByteBuffer) m1.getAllParams()[0];
serverEngine.feedEncryptedPacket(b3, null);
m = serverList.expect("runTask");
Runnable r = (Runnable) m.getAllParams()[0];
r.run();
m = serverList.expect("packetEncrypted");
b = (ByteBuffer) m.getAllParams()[0];
clientEngine.feedEncryptedPacket(b, null);
m = clientList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
String[] methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "packetEncrypted";
CalledMethod[] methods = clientList.expect(methodNames);
ByteBuffer b0 = (ByteBuffer) methods[0].getAllParams()[0];
ByteBuffer b1 = (ByteBuffer) methods[1].getAllParams()[0];
ByteBuffer b2 = (ByteBuffer) methods[2].getAllParams()[0];
int total = b0.remaining() + b1.remaining() + b2.remaining();
ByteBuffer combined = ByteBuffer.allocate(total);
combined.put(b0);
combined.put(b1);
combined.put(b2);
helper.doneFillingBuffer(combined);
serverEngine.feedEncryptedPacket(combined, null);
m = serverList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "encryptedLinkEstablished";
methods = serverList.expect(methodNames);
b0 = (ByteBuffer) methods[0].getAllParams()[0];
b1 = (ByteBuffer) methods[1].getAllParams()[0];
total = b0.remaining() + b1.remaining();
combined = ByteBuffer.allocate(total);
combined.put(b0);
combined.put(b1);
helper.doneFillingBuffer(combined);
clientEngine.feedEncryptedPacket(combined, null);
clientList.expect("encryptedLinkEstablished");
}
public void testOneAndHalfPackets() throws Exception {
clientEngine.beginHandshake();
CalledMethod m = clientList.expect("packetEncrypted");
ByteBuffer b = (ByteBuffer) m.getAllParams()[0];
serverEngine.feedEncryptedPacket(b, null);
m = serverList.expect("runTask");
Runnable r = (Runnable) m.getAllParams()[0];
r.run();
m = serverList.expect("packetEncrypted");
b = (ByteBuffer) m.getAllParams()[0];
clientEngine.feedEncryptedPacket(b, null);
m = clientList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
String[] methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "packetEncrypted";
CalledMethod[] methods = clientList.expect(methodNames);
ByteBuffer b0 = (ByteBuffer) methods[0].getAllParams()[0];
ByteBuffer b1 = (ByteBuffer) methods[1].getAllParams()[0];
ByteBuffer b2 = (ByteBuffer) methods[2].getAllParams()[0];
int total = b0.remaining() + b1.remaining() + b2.remaining();
ByteBuffer combined = ByteBuffer.allocate(total);
combined.put(b0);
int lim = b1.limit();
b1.limit(3); // we only want to put part of b1 in payload
combined.put(b1);
helper.doneFillingBuffer(combined);
serverEngine.feedEncryptedPacket(combined, null);
combined.clear();
b1.limit(lim);
combined.put(b1);
combined.put(b2);
helper.doneFillingBuffer(combined);
serverEngine.feedEncryptedPacket(combined, null);
m = serverList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "encryptedLinkEstablished";
methods = serverList.expect(methodNames);
b0 = (ByteBuffer) methods[0].getAllParams()[0];
b1 = (ByteBuffer) methods[1].getAllParams()[0];
total = b0.remaining() + b1.remaining();
combined = ByteBuffer.allocate(total);
combined.put(b0);
combined.put(b1);
helper.doneFillingBuffer(combined);
clientEngine.feedEncryptedPacket(combined, null);
clientList.expect("encryptedLinkEstablished");
}
public void testRunInMiddleOfPacket() throws Exception {
log.fine("B*******************************************");
clientEngine.beginHandshake();
CalledMethod m = clientList.expect("packetEncrypted");
ByteBuffer b = (ByteBuffer) m.getAllParams()[0];
serverEngine.feedEncryptedPacket(b, null);
m = serverList.expect("runTask");
Runnable r = (Runnable) m.getAllParams()[0];
r.run();
m = serverList.expect("packetEncrypted");
b = (ByteBuffer) m.getAllParams()[0];
clientEngine.feedEncryptedPacket(b, null);
m = clientList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
r.run();
String[] methodNames = new String[3];
methodNames[0] = "packetEncrypted";
methodNames[1] = "packetEncrypted";
methodNames[2] = "packetEncrypted";
CalledMethod[] methods = clientList.expect(methodNames);
ByteBuffer b0 = (ByteBuffer) methods[0].getAllParams()[0];
ByteBuffer b1 = (ByteBuffer) methods[1].getAllParams()[0];
ByteBuffer b2 = (ByteBuffer) methods[2].getAllParams()[0];
serverEngine.feedEncryptedPacket(b0, null);
m = serverList.expect("runTask");
r = (Runnable) m.getAllParams()[0];
int total = b1.remaining() + b2.remaining();
ByteBuffer combined = ByteBuffer.allocate(total);
int lim = b1.limit();
b1.limit(3); // we only want to put part of b1 in payload
combined.put(b1);
helper.doneFillingBuffer(combined);
serverEngine.feedEncryptedPacket(combined, null);
// run the task after some of the previous packet fed, then feed rest of packet
r.run();
combined.clear();
b1.limit(lim);
combined.put(b1);
combined.put(b2);
helper.doneFillingBuffer(combined);
serverEngine.feedEncryptedPacket(combined, null);
String[] methodNames1 = new String[3];
methodNames1[0] = "packetEncrypted";
methodNames1[1] = "packetEncrypted";
methodNames1[2] = "encryptedLinkEstablished";
CalledMethod[] methods1 = serverList.expect(methodNames1);
b0 = (ByteBuffer) methods1[0].getAllParams()[0];
clientEngine.feedEncryptedPacket(b0, null);
b1 = (ByteBuffer) methods1[1].getAllParams()[0];
clientEngine.feedEncryptedPacket(b1, null);
clientList.expect("encryptedLinkEstablished");
}
private void feedPacket(AsyncSSLEngine engine, ByteBuffer b) throws Exception {
TestNewAsynchSSLEngine.feedPacket(engine, b);
}
}
public abstract class ZNioSuperclassTest extends TestCase {
private static final Logger log = Logger.getLogger(ZNioSuperclassTest.class.getName());
private BufferFactory bufFactory;
private InetSocketAddress svrAddr;
private ChannelService chanMgr;
private InetAddress loopBack;
private InetSocketAddress loopBackAnyPort;
private BufferHelper helper = ChannelServiceFactory.bufferHelper(null);
private MockObject mockHandler;
private MockObject mockConnect;
private TCPChannel client1;
private MockNIOServer mockServer;
protected abstract ChannelService getClientChanMgr();
protected abstract ChannelService getServerChanMgr();
protected abstract Settings getServerFactoryHolder();
protected abstract Settings getClientFactoryHolder();
protected abstract String getChannelImplName();
protected abstract String getServerChannelImplName();
public ZNioSuperclassTest() {
if (bufFactory == null) {
Map<String, Object> map = new HashMap<String, Object>();
map.put(FactoryCreator.KEY_IS_DIRECT, false);
FactoryCreator creator = FactoryCreator.createFactory(null);
bufFactory = creator.createBufferFactory(map);
}
}
protected void setUp() throws Exception {
HandlerForTests.setupLogging();
// here I keep using the same channel manager on purpose, just
// so we get testing between tests that the channel manager shutdown
// and started back up cleanly.....
if (chanMgr == null) {
chanMgr = getClientChanMgr();
}
if (mockServer == null) {
ChannelService svcChanMgr = getServerChanMgr();
mockServer = new MockNIOServer(svcChanMgr, getServerFactoryHolder());
}
chanMgr.start();
svrAddr = mockServer.start();
log.fine("server port =" + svrAddr);
loopBack = InetAddress.getByName("127.0.0.1");
loopBackAnyPort = new InetSocketAddress(loopBack, 0);
mockHandler = MockObjectFactory.createMock(DataListener.class);
mockHandler.setDefaultBehavior("incomingData", new CloneByteBuffer());
mockConnect = MockObjectFactory.createMock(ConnectionCallback.class);
client1 = chanMgr.createTCPChannel("ClientChannel", getClientFactoryHolder());
}
protected void tearDown() throws Exception {
log.info("CHAN MGR STOP");
chanMgr.stop();
chanMgr = null;
log.info("MOCK SERVER STOP");
mockServer.stop();
log.info("check for warns");
HandlerForTests.checkForWarnings();
log.info("done");
}
// TODO: write test that proves if data comes between calls to Selector.select,
// the next selector.select will still trigger even if we cleared the key from
// the list of selected keys.
public void testDataComesBetweenSelects() throws Exception {}
// public void testClientThrowsIntoConnectCallback() throws Exception {
// //make sure we are testing the right one....
// Class c = Class.forName(getChannelImplName());
// assertEquals("should be instance of correct channel type", c, client1.getClass());
//
// String msg = "some exception message";
// IOException e = new IOException(msg);
// mockConnect.addThrowException("connected", e);
//
// client1.bind(loopBackAnyPort);
// client1.registerForReads((DataHandler)mockHandler);
// client1.connect(svrAddr, (ConnectCallback)mockConnect);
//
// mockConnect.expect("connected");
// TCPChannel svrChan = (TCPChannel)mockServer.expect(MockNIOServer.CONNECTED).getAllParams()[0];
// assertEquals("should be instance of correct channel type", c, svrChan.getClass());
//
// verifyDataPassing(svrChan);
// verifyTearDown();
// }
/**
* This cannot pass on linux right now as warnings end up in the log from reads firing even though
* there should be none if not connected. We can fix this later if it is needed.
*
* <p>Order between TCPChannel.connect and TCPChannel.registerForRead results in different code
* paths...this is one of the tests.
*
* @throws Exception
*/
public void xtestRegisterForReadsBeforeConnect() throws Exception {
// make sure we are testing the right one....
Class c = Class.forName(getChannelImplName());
assertEquals("should be instance of correct channel type", c, client1.getClass());
client1.bind(loopBackAnyPort);
client1.registerForReads((DataListener) mockHandler);
client1.oldConnect(svrAddr, (ConnectionCallback) mockConnect);
mockConnect.expect("connected");
boolean isConnected = client1.isConnected();
assertTrue("Client should be connected", isConnected);
TCPChannel svrChan = ZNioFailureSuperclass.expectServerChannel(mockServer, c);
verifyDataPassing(svrChan);
verifyTearDown();
}
/** */
public void testConnectClose() throws Exception {
// make sure we are testing the right one....
// Class c = Class.forName(getChannelImplName());
// assertEquals("should be instance of secure channel", c, client1.getClass());
// no bind, just do connect to test port is not zero
client1.oldConnect(svrAddr, (ConnectionCallback) mockConnect);
mockConnect.expect("connected");
mockServer.expect(MockNIOServer.CONNECTED);
verifyTearDown();
}
/**
* Order between TCPChannel.connect and TCPChannel.registerForRead results in different code
* paths...this is one of the tests.
*
* @throws Exception
*/
public void testRegisterForReadsAfterConnect() throws Exception {
// make sure we are testing the right one....
Class c = Class.forName(getChannelImplName());
assertEquals("should be instance of secure channel", c, client1.getClass());
// no bind, just do connect to test port is not zero
client1.oldConnect(svrAddr, (ConnectionCallback) mockConnect);
mockConnect.expect("connected");
log.info("connected");
boolean isConnected = client1.isConnected();
assertTrue("Client should be connected", isConnected);
InetSocketAddress localAddr = client1.getLocalAddress();
assertTrue("Port should not be 0", localAddr.getPort() != 0);
TCPChannel svrChan = ZNioFailureSuperclass.expectServerChannel(mockServer, c);
client1.registerForReads((DataListener) mockHandler);
log.info("data passing");
verifyDataPassing(svrChan);
log.info("teardown");
verifyTearDown();
log.info("done");
}
/**
* Test closing socket before ChannelManager shutdown works.
*
* @throws Exception
*/
public void testCloseSvrSocketBeforeChannelMgrShutdown() throws Exception {
Class c = Class.forName(getChannelImplName());
client1.bind(loopBackAnyPort);
client1.oldConnect(svrAddr);
boolean isConnected = client1.isConnected();
assertTrue("Client should be connected", isConnected);
TCPChannel svrChan = ZNioFailureSuperclass.expectServerChannel(mockServer, c);
client1.registerForReads((DataListener) mockHandler);
verifyDataPassing(svrChan);
svrChan.oldClose();
// shutdown channel manager first
mockServer.stop();
mockHandler.expect(MockNIOServer.FAR_END_CLOSED);
}
/**
* There was a bug where calling ChannelManager.shutdown before closing any sockets registered
* with that ChannelManager cannot be closed...well, at least this test proves when we close the
* test, the other side should receive that -1 indicating the far end closed the socket.
*
* @throws Exception
*/
public void testCloseSocketAfterChannelMgrShutdown() throws Exception {
Class c = Class.forName(getChannelImplName());
client1.bind(loopBackAnyPort);
client1.oldConnect(svrAddr);
TCPChannel svrChan = ZNioFailureSuperclass.expectServerChannel(mockServer, c);
client1.registerForReads((DataListener) mockHandler);
verifyDataPassing(svrChan);
// shutdown channel manager first....should all sockets be closed? Right now
// someone has to manually close all accepted sockets...ie. client responsibility.
svrChan.oldClose();
mockServer.stop();
// notice the Channelmanager on the client side has not shut down so we should
// see a close event....
mockHandler.expect(MockNIOServer.FAR_END_CLOSED);
}
public void testUnregisterReregisterForReads() throws Exception {
Class c = Class.forName(getChannelImplName());
client1.bind(loopBackAnyPort);
client1.oldConnect(svrAddr);
TCPChannel svrChan = ZNioFailureSuperclass.expectServerChannel(mockServer, c);
client1.registerForReads((DataListener) mockHandler);
ByteBuffer b = verifyDataPassing(svrChan);
client1.unregisterForReads();
b.rewind();
svrChan.oldWrite(b);
Thread.sleep(5000);
mockHandler.expect(MockObject.NONE);
client1.registerForReads((DataListener) mockHandler);
CalledMethod m = mockHandler.expect(MockNIOServer.INCOMING_DATA);
ByteBuffer actualBuf = (ByteBuffer) m.getAllParams()[1];
String result = helper.readString(actualBuf, actualBuf.remaining());
assertEquals("de", result);
verifyTearDown();
}
/**
* the first 1.5.0 jdk threw Errors on this test case instead of BindException or SocketException.
* Our ChannelManager converts the Error back if it is a SocketException.
*
* @throws Exception
*/
public void testAlreadyBound150Jdk() throws Exception {
client1.bind(loopBackAnyPort);
try {
client1.bind(loopBackAnyPort);
fail("Should have thrown SocketException");
} catch (NioException e) {
}
}
/**
* This fixes the bug in the jdk where SocketChannel.getLocalPort return 0 instead of the port
* that was bound.
*
* @throws Exception
*/
public void testTwoBindsOnPortZero() throws Exception {
TCPChannel chan1 = chanMgr.createTCPChannel("chan1", getClientFactoryHolder());
TCPChannel chan2 = chanMgr.createTCPChannel("chan2", getClientFactoryHolder());
InetSocketAddress addr = new InetSocketAddress(loopBack, 0);
chan1.bind(addr);
chan2.bind(addr);
int port1 = chan1.getLocalAddress().getPort();
int port2 = chan2.getLocalAddress().getPort();
assertTrue("port1 is zero, this is bad", port1 != 0);
assertTrue("port2 is zero, this is bad", port2 != 0);
assertTrue("port1==port2, this is bad port1=" + port1, port1 != port2);
}
public void testBindThroughConnect() throws Exception {
client1.oldConnect(svrAddr);
int port = client1.getLocalAddress().getPort();
assertTrue("port is zero, this is bad", port != 0);
mockServer.expect("connected");
// verifyTearDown();
}
private ByteBuffer verifyDataPassing(TCPChannel svrChan) throws Exception {
ByteBuffer b = ByteBuffer.allocate(10);
helper.putString(b, "de");
helper.doneFillingBuffer(b);
int expectedWrote = b.remaining();
log.fine("***********************************************");
int actualWrite = client1.oldWrite(b);
assertEquals(expectedWrote, actualWrite);
CalledMethod m = mockServer.expect(MockNIOServer.INCOMING_DATA);
TCPChannel actualChannel = (TCPChannel) m.getAllParams()[0];
Class c = Class.forName(getChannelImplName());
assertEquals("should be correct type of channel", c, actualChannel.getClass());
ByteBuffer actualBuf = (ByteBuffer) m.getAllParams()[1];
String result = helper.readString(actualBuf, actualBuf.remaining());
assertEquals("de", result);
b.rewind();
svrChan.oldWrite(b);
m = mockHandler.expect(MockDataHandler.INCOMING_DATA);
actualBuf = (ByteBuffer) m.getAllParams()[1];
result = helper.readString(actualBuf, actualBuf.remaining());
assertEquals("de", result);
return b;
}
private void verifyTearDown() throws IOException {
log.info("local=" + client1.getLocalAddress() + " remote=" + client1.getRemoteAddress());
log.info("CLIENT1 CLOSE");
client1.oldClose();
mockServer.expect(MockNIOServer.FAR_END_CLOSED);
}
protected Object getBufFactory() {
return bufFactory;
}
}