PROTON-1583: some additional tests
diff --git a/proton-j/src/test/java/org/apache/qpid/proton/engine/impl/TransportImplTest.java b/proton-j/src/test/java/org/apache/qpid/proton/engine/impl/TransportImplTest.java
index 80ad20c..ff5a5b4 100644
--- a/proton-j/src/test/java/org/apache/qpid/proton/engine/impl/TransportImplTest.java
+++ b/proton-j/src/test/java/org/apache/qpid/proton/engine/impl/TransportImplTest.java
@@ -1707,6 +1707,162 @@
}
@Test
+ public void testTickWithLocalTimeout()
+ {
+ // all-positive
+ doTickWithLocalTimeoutTestImpl(4000, 10000, 14000, 18000, 22000);
+
+ // all-negative
+ doTickWithLocalTimeoutTestImpl(2000, -100000, -98000, -96000, -94000);
+
+ // negative to positive missing 0
+ doTickWithLocalTimeoutTestImpl(500, -950, -450, 50, 550);
+
+ // negative to positive striking 0
+ doTickWithLocalTimeoutTestImpl(3000, -6000, -3000, 1, 3001);
+ }
+
+ private void doTickWithLocalTimeoutTestImpl(int localTimeout, long tick1, long expectedDeadline1, long expectedDeadline2, long expectedDeadline3)
+ {
+ MockTransportImpl transport = new MockTransportImpl();
+ Connection connection = Proton.connection();
+ transport.bind(connection);
+
+ // Set our local idleTimeout
+ transport.setIdleTimeout(localTimeout);
+
+ connection.open();
+ pumpMockTransport(transport);
+
+ assertEquals("should have written data", 1, transport.writes.size());
+ Object sentOpenFrame = transport.writes.get(0);
+ assertNotNull("should have written a non-empty frame", sentOpenFrame);
+ assertTrue("should have written an open frame", sentOpenFrame instanceof Open);
+ assertEquals("should have had an idletimeout value half our actual timeout", UnsignedInteger.valueOf(localTimeout / 2), ((Open)sentOpenFrame).getIdleTimeOut());
+
+ // Receive Protocol header
+ processInput(transport, ByteBuffer.wrap(new byte[] {'A', 'M', 'Q', 'P', 0x00, 0x01, 0x00, 0x00}));
+
+ // Handle the peer transmitting their open, without timeout.
+ Open open = new Open();
+ open.setIdleTimeOut(null);
+ TransportFrame openFrame = new TransportFrame(CHANNEL_ID, open, null);
+ transport.handleFrame(openFrame);
+ pumpMockTransport(transport);
+
+ long deadline = transport.tick(tick1);
+ assertEquals("Unexpected deadline returned", expectedDeadline1, deadline);
+
+ // Wait for less time than the deadline with no data - get the same value
+ long interimTick = tick1 + 10;
+ assertTrue (interimTick < expectedDeadline1);
+ assertEquals("When the deadline hasn't been reached tick() should return the previous deadline", expectedDeadline1, transport.tick(interimTick));
+ assertEquals("When the deadline hasn't been reached tick() shouldn't write data", 1, transport.writes.size());
+
+ // Receive Empty frame to satisfy local deadline
+ processInput(transport, ByteBuffer.wrap(new byte[] {0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00}));
+
+ deadline = transport.tick(expectedDeadline1);
+ assertEquals("When the deadline has been reached expected a new local deadline to be returned", expectedDeadline2, deadline);
+ assertEquals("When the deadline hasn't been reached tick() shouldn't write data", 1, transport.writes.size());
+
+ pumpMockTransport(transport);
+
+ // Receive Empty frame to satisfy local deadline
+ processInput(transport, ByteBuffer.wrap(new byte[] {0x00, 0x00, 0x00, 0x08, 0x02, 0x00, 0x00, 0x00}));
+
+ deadline = transport.tick(expectedDeadline2);
+ assertEquals("When the deadline has been reached expected a new local deadline to be returned", expectedDeadline3, deadline);
+ assertEquals("When the deadline hasn't been reached tick() shouldn't write data", 1, transport.writes.size());
+
+ pumpMockTransport(transport);
+
+ assertEquals("Connection should be active", EndpointState.ACTIVE, connection.getLocalState());
+ transport.tick(expectedDeadline3); // Wait for the deadline, but don't receive traffic, allow local timeout to expire
+ assertEquals("Calling tick() after the deadline should result in the connection being closed", EndpointState.CLOSED, connection.getLocalState());
+ assertEquals("tick() should have written data", 2, transport.writes.size());
+ assertNotNull("should have written a non-empty frame", transport.writes.get(1));
+ assertTrue("should have written a close frame", transport.writes.get(1) instanceof Close);
+ }
+
+ @Test
+ public void testTickWithRemoteTimeout()
+ {
+ // all-positive
+ doTickWithRemoteTimeoutTestImpl(4000, 10000, 14000, 18000, 22000);
+
+ // all-negative
+ doTickWithRemoteTimeoutTestImpl(2000, -100000, -98000, -96000, -94000);
+
+ // negative to positive missing 0
+ doTickWithRemoteTimeoutTestImpl(500, -950, -450, 50, 550);
+
+ // negative to positive striking 0
+ doTickWithRemoteTimeoutTestImpl(3000, -6000, -3000, 1, 3001);
+ }
+
+ private void doTickWithRemoteTimeoutTestImpl(int remoteTimeoutHalf, long tick1, long expectedDeadline1, long expectedDeadline2, long expectedDeadline3)
+ {
+ MockTransportImpl transport = new MockTransportImpl();
+ Connection connection = Proton.connection();
+ transport.bind(connection);
+
+ connection.open();
+ pumpMockTransport(transport);
+
+ assertEquals("should have written data", 1, transport.writes.size());
+ Object sentOpenFrame = transport.writes.get(0);
+ assertNotNull("should have written a non-empty frame", sentOpenFrame);
+ assertTrue("should have written an open frame", sentOpenFrame instanceof Open);
+ assertNull("should not have had an idletimeout value", ((Open)sentOpenFrame).getIdleTimeOut());
+
+ // Receive Protocol header
+ processInput(transport, ByteBuffer.wrap(new byte[] {'A', 'M', 'Q', 'P', 0x00, 0x01, 0x00, 0x00}));
+
+ // Handle the peer transmitting [half] their timeout. We half it on receipt to avoid spurious timeouts
+ // if they not have transmitted half their actual timeout, as the AMQP spec only says they SHOULD do that.
+ Open open = new Open();
+ open.setIdleTimeOut(new UnsignedInteger(remoteTimeoutHalf * 2));
+ TransportFrame openFrame = new TransportFrame(CHANNEL_ID, open, null);
+ transport.handleFrame(openFrame);
+ pumpMockTransport(transport);
+
+ long deadline = transport.tick(tick1);
+ assertEquals("Unexpected deadline returned", expectedDeadline1, deadline);
+
+ // Wait for less time than the deadline with no data - get the same value
+ long interimTick = tick1 + 10;
+ assertTrue (interimTick < expectedDeadline1);
+ assertEquals("When the deadline hasn't been reached tick() should return the previous deadline", expectedDeadline1, transport.tick(interimTick));
+ assertEquals("When the deadline hasn't been reached tick() shouldn't write data", 1, transport.writes.size());
+
+ deadline = transport.tick(expectedDeadline1);
+ assertEquals("When the deadline has been reached expected a new remote deadline to be returned", expectedDeadline2, deadline);
+ assertEquals("tick() should have written data", 2, transport.writes.size());
+ assertEquals("tick() should have written an empty frame", null, transport.writes.get(1));
+
+ pumpMockTransport(transport);
+
+ // Do some actual work, create real traffic, removing the need to send empty frame to satisfy idle-timeout
+ connection.session().open();
+ pumpMockTransport(transport);
+ assertEquals("session open should have written data", 3, transport.writes.size());
+ Object sentBeginFrame = transport.writes.get(2);
+ assertNotNull("should have written a non-empty frame", sentBeginFrame);
+ assertTrue("session open should have written a Begin frame", sentBeginFrame instanceof Begin);
+
+ deadline = transport.tick(expectedDeadline2);
+ assertEquals("When the deadline has been reached expected a new remote deadline to be returned", expectedDeadline3, deadline);
+ assertEquals("tick() should not have written data as there was actual activity", 3, transport.writes.size());
+
+ pumpMockTransport(transport);
+
+ transport.tick(expectedDeadline3);
+ assertEquals("tick() should have written data", 4, transport.writes.size());
+ assertEquals("tick() should have written an empty frame", null, transport.writes.get(1));
+ }
+
+ @Test
public void testTickWithBothTimeouts()
{
// all-positive
@@ -1747,6 +1903,9 @@
assertNotNull("should have written a non-empty frame", transport.writes.get(0));
assertTrue("should have written an open frame", transport.writes.get(0) instanceof Open);
+ // Receive Protocol header
+ processInput(transport, ByteBuffer.wrap(new byte[] {'A', 'M', 'Q', 'P', 0x00, 0x01, 0x00, 0x00}));
+
// Handle the peer transmitting [half] their timeout. We half it on receipt to avoid spurious timeouts
// if they not have transmitted half their actual timeout, as the AMQP spec only says they SHOULD do that.
Open open = new Open();
@@ -1831,6 +1990,9 @@
assertNotNull("should have written a non-empty frame", transport.writes.get(0));
assertTrue("should have written an open frame", transport.writes.get(0) instanceof Open);
+ // Receive Protocol header
+ processInput(transport, ByteBuffer.wrap(new byte[] {'A', 'M', 'Q', 'P', 0x00, 0x01, 0x00, 0x00}));
+
// Handle the peer transmitting [half] their timeout. We half it on receipt to avoid spurious timeouts
// if they not have transmitted half their actual timeout, as the AMQP spec only says they SHOULD do that.
Open open = new Open();
