[jboss-cvs] JBossRemoting/src/tests/org/jboss/test/remoting/callback/acknowledge ...
Ron Sigal
ron_sigal at yahoo.com
Sun Oct 29 15:24:24 EST 2006
User: rsigal
Date: 06/10/29 15:24:24
Modified: src/tests/org/jboss/test/remoting/callback/acknowledge
CallbackAcknowledgeTestCase.java
Log:
JBREM-605: Added unit tests, and send > 1 callback per test.
Revision Changes Path
1.2 +223 -36 JBossRemoting/src/tests/org/jboss/test/remoting/callback/acknowledge/CallbackAcknowledgeTestCase.java
(In the diff below, changes in quantity of whitespace are not shown.)
Index: CallbackAcknowledgeTestCase.java
===================================================================
RCS file: /cvsroot/jboss/JBossRemoting/src/tests/org/jboss/test/remoting/callback/acknowledge/CallbackAcknowledgeTestCase.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -b -r1.1 -r1.2
--- CallbackAcknowledgeTestCase.java 25 Sep 2006 23:48:34 -0000 1.1
+++ CallbackAcknowledgeTestCase.java 29 Oct 2006 20:24:24 -0000 1.2
@@ -34,10 +34,11 @@
import java.net.InetAddress;
import java.util.HashMap;
import java.util.List;
-import java.util.Map;
import javax.management.MBeanServer;
+import junit.framework.TestCase;
+
import org.jboss.logging.Logger;
import org.jboss.remoting.Client;
import org.jboss.remoting.InvocationRequest;
@@ -53,13 +54,12 @@
import org.jboss.remoting.transport.Connector;
import org.jboss.remoting.transport.PortUtil;
-import junit.framework.TestCase;
-
public class CallbackAcknowledgeTestCase extends TestCase
{
private static String PREPROCESS_TEST = "preprocessTest";
private static String POSTPROCESS_TEST = "postprocessTest";
+ private static String PRE_AND_POSTPROCESS_TEST = "preAndPostprocessTest";
private static Logger log = Logger.getLogger(CallbackAcknowledgeTestCase.class);
private Connector connector;
@@ -84,7 +84,7 @@
TestInvoocationHandler.acknowledgedPreprocess = false;
TestInvoocationHandler.acknowledgedPostprocess = false;
- TestCallbackHandler.receivedCallback = false;
+ TestCallbackHandler.callbacksReceived = 0;
}
@@ -117,23 +117,12 @@
assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
List callbacks = client.getCallbacks(callbackHandler);
+ assertEquals(2, callbacks.size());
assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
- Callback callback = (Callback) callbacks.get(0);
-
- try
- {
- client.acknowledgeCallback(callbackHandler, callback);
- log.error("didn't get expected exception");
- fail();
- }
- catch (Exception e)
- {
- assertTrue("Will not acknowledge Callback because it has no registered Listener.".equals(e.getMessage()));
- }
-
Thread.sleep(1000);
- assertFalse(TestCallbackHandler.receivedCallback);
+ assertEquals(0, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
log.info(getName() + " PASSES");
}
catch (Throwable e)
@@ -161,14 +150,88 @@
assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
client.invoke(POSTPROCESS_TEST);
List callbacks = client.getCallbacks(callbackHandler);
- Callback callback = (Callback) callbacks.get(0);
+ assertEquals(2, callbacks.size());
assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
- client.acknowledgeCallback(callbackHandler, callback);
+ assertEquals(2, client.acknowledgeCallbacks(callbackHandler, callbacks));
assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
assertTrue(TestInvoocationHandler.acknowledgedPostprocess);
Thread.sleep(1000);
- assertFalse(TestCallbackHandler.receivedCallback);
+ assertEquals(0, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
+ log.info(getName() + " PASSES");
+ }
+ catch (Throwable e)
+ {
+ log.info(getName() + " FAILS");
+ e.printStackTrace();
+ fail();
+ }
+ }
+
+
+ /**
+ * In this test, the connection is configured for true pull callbacks, and the
+ * acknowledgements should be made implicitly by ServerInvokerCallbackHandler
+ * during the call to getCallbacks() (before the callbacks are retrieved by
+ * the client) and later by an explicit call to Client.acknowledgeCallback()
+ * after the callback has been retrieved and (presumably) processed.
+ */
+ public void testPullCallbackPreAndPostprocessAcknowledgement()
+ {
+ log.info("entering " + getName());
+ try
+ {
+ TestCallbackHandler callbackHandler = new TestCallbackHandler();
+ client.addListener(callbackHandler);
+ assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ client.invoke(PRE_AND_POSTPROCESS_TEST);
+ List callbacks = client.getCallbacks(callbackHandler);
+ assertEquals(2, callbacks.size());
+ assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ assertEquals(2, client.acknowledgeCallbacks(callbackHandler, callbacks));
+ assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
+ assertTrue(TestInvoocationHandler.acknowledgedPostprocess);
+ Thread.sleep(1000);
+ assertEquals(0, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
+ log.info(getName() + " PASSES");
+ }
+ catch (Throwable e)
+ {
+ log.info(getName() + " FAILS");
+ e.printStackTrace();
+ fail();
+ }
+ }
+
+
+ /**
+ * In this test the connection is configured for push callbacks implemented in
+ * Remoting by polling the server for callbacks and pushing them (on the client
+ * side) to the InvokerCallbackHandler. The acknowledgement should be made
+ * implicitly by ServerInvokerCallbackHandler during the call to getCallbacks()
+ * (before the callbacks are retrieved by the client).
+ */
+ public void testPollCallbackPreprocessAcknowledgement()
+ {
+ log.info("entering " + getName());
+ try
+ {
+ TestCallbackHandler callbackHandler = new TestCallbackHandler();
+ HashMap metadata = new HashMap();
+ metadata.put(CallbackPoller.CALLBACK_POLL_PERIOD, "100");
+ client.addListener(callbackHandler, metadata);
+ assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ client.invoke(PREPROCESS_TEST);
+ Thread.sleep(1000);
+ assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ assertEquals(2, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
log.info(getName() + " PASSES");
}
catch (Throwable e)
@@ -198,11 +261,79 @@
client.addListener(callbackHandler, metadata);
assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
- client.invoke(POSTPROCESS_TEST);
+ client.invoke(PREPROCESS_TEST);
Thread.sleep(1000);
+ assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ assertEquals(2, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
+ log.info(getName() + " PASSES");
+ }
+ catch (Throwable e)
+ {
+ log.info(getName() + " FAILS");
+ e.printStackTrace();
+ fail();
+ }
+ }
+
+
+ /**
+ * In this test the connection is configured for push callbacks implemented in
+ * Remoting by polling the server for callbacks and pushing them (on the client
+ * side) to the InvokerCallbackHandler. The acknowledgements should be made
+ * implicitly by ServerInvokerCallbackHandler during the call to getCallbacks()
+ * (before the callbacks are retrieved by the client), and then
+ * implicitly by CallbackPoller, which it does by calling Client.acknowledgeCallback()
+ * after it has pushed the callback to the InvokerCallbackHandler.
+ */
+ public void testPollCallbackPreAndPostprocessAcknowledgement()
+ {
+ log.info("entering " + getName());
+ try
+ {
+ TestCallbackHandler callbackHandler = new TestCallbackHandler();
+ HashMap metadata = new HashMap();
+ metadata.put(CallbackPoller.CALLBACK_POLL_PERIOD, "100");
+ client.addListener(callbackHandler, metadata);
assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ client.invoke(PRE_AND_POSTPROCESS_TEST);
+ Thread.sleep(1000);
+ assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
assertTrue(TestInvoocationHandler.acknowledgedPostprocess);
- assertTrue(TestCallbackHandler.receivedCallback);
+ assertEquals(2, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
+ log.info(getName() + " PASSES");
+ }
+ catch (Throwable e)
+ {
+ log.info(getName() + " FAILS");
+ e.printStackTrace();
+ fail();
+ }
+ }
+
+
+ /**
+ * In this test the connection is configured for true push callbacks, and the
+ * acknowledgement should be made by ServerInvokerCallbackHandler.handleCallback()
+ * after it has pushed the Callback to the client.
+ */
+ public void testPushCallbackPreprocessAcknowledgement()
+ {
+ log.info("entering " + getName());
+ try
+ {
+ TestCallbackHandler callbackHandler = new TestCallbackHandler();
+ client.addListener(callbackHandler, null, null, true);
+ assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ client.invoke(PREPROCESS_TEST);
+ assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ assertEquals(2, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
log.info(getName() + " PASSES");
}
catch (Throwable e)
@@ -231,7 +362,8 @@
client.invoke(POSTPROCESS_TEST);
assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
assertTrue(TestInvoocationHandler.acknowledgedPostprocess);
- assertTrue(TestCallbackHandler.receivedCallback);
+ assertEquals(2, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
log.info(getName() + " PASSES");
}
catch (Throwable e)
@@ -242,6 +374,38 @@
}
}
+
+
+ /**
+ * In this test the connection is configured for true push callbacks, and the
+ * acknowledgements should be made by ServerInvokerCallbackHandler.handleCallback()
+ * after it has pushed the Callback to the client.
+ */
+ public void testPushCallbackPreAndPostprocessAcknowledgement()
+ {
+ log.info("entering " + getName());
+ try
+ {
+ TestCallbackHandler callbackHandler = new TestCallbackHandler();
+ client.addListener(callbackHandler, null, null, true);
+ assertFalse(TestInvoocationHandler.acknowledgedPreprocess);
+ assertFalse(TestInvoocationHandler.acknowledgedPostprocess);
+ client.invoke(PRE_AND_POSTPROCESS_TEST);
+ assertTrue(TestInvoocationHandler.acknowledgedPreprocess);
+ assertTrue(TestInvoocationHandler.acknowledgedPostprocess);
+ assertEquals(2, TestCallbackHandler.callbacksReceived);
+ client.removeListener(callbackHandler);
+ log.info(getName() + " PASSES");
+ }
+ catch (Throwable e)
+ {
+ log.info(getName() + " FAILS");
+ e.printStackTrace();
+ fail();
+ }
+ }
+
+
static class TestInvoocationHandler implements ServerInvocationHandler, CallbackListener
{
static boolean acknowledgedPreprocess;
@@ -259,22 +423,45 @@
public Object invoke(InvocationRequest invocation) throws Throwable
{
+
String command = (String) invocation.getParameter();
+ System.out.println("command: " + command);
if (PREPROCESS_TEST.equals(command))
{
- Callback cb = new Callback("preprocess");
+ Callback cb1 = new Callback(PREPROCESS_TEST + "1");
+ Callback cb2 = new Callback(PREPROCESS_TEST + "2");
HashMap returnPayload = new HashMap();
returnPayload.put(ServerInvokerCallbackHandler.CALLBACK_PREPROCESS_LISTENER, this);
- cb.setReturnPayload(returnPayload);
- callbackHandler.handleCallback(cb);
+ returnPayload.put(ServerInvokerCallbackHandler.CALLBACK_ID, "preprocess");
+ cb1.setReturnPayload(returnPayload);
+ cb2.setReturnPayload(returnPayload);
+ callbackHandler.handleCallback(cb1);
+ callbackHandler.handleCallback(cb2);
}
else if (POSTPROCESS_TEST.equals(command))
{
- Callback cb = new Callback("postprocess");
+ Callback cb1 = new Callback(POSTPROCESS_TEST + "1");
+ Callback cb2 = new Callback(POSTPROCESS_TEST + "2");
HashMap returnPayload = new HashMap();
returnPayload.put(ServerInvokerCallbackHandler.CALLBACK_POSTPROCESS_LISTENER, this);
- cb.setReturnPayload(returnPayload);
- callbackHandler.handleCallback(cb);
+ returnPayload.put(ServerInvokerCallbackHandler.CALLBACK_ID, "postprocess");
+ cb1.setReturnPayload(returnPayload);
+ cb2.setReturnPayload(returnPayload);
+ callbackHandler.handleCallback(cb1);
+ callbackHandler.handleCallback(cb2);
+ }
+ else if (PRE_AND_POSTPROCESS_TEST.equals(command))
+ {
+ Callback cb1 = new Callback(PRE_AND_POSTPROCESS_TEST + "1");
+ Callback cb2 = new Callback(PRE_AND_POSTPROCESS_TEST + "2");
+ HashMap returnPayload = new HashMap();
+ returnPayload.put(ServerInvokerCallbackHandler.CALLBACK_PREPROCESS_LISTENER, this);
+ returnPayload.put(ServerInvokerCallbackHandler.CALLBACK_POSTPROCESS_LISTENER, this);
+ returnPayload.put(ServerInvokerCallbackHandler.CALLBACK_ID, "postprocess");
+ cb1.setReturnPayload(returnPayload);
+ cb2.setReturnPayload(returnPayload);
+ callbackHandler.handleCallback(cb1);
+ callbackHandler.handleCallback(cb2);
}
return null;
@@ -289,14 +476,14 @@
{
}
- public void callbackSent(Callback callback)
+ public void callbackSent(Object callbackId, int preOrPost)
{
- if ("preprocess".equals(callback.getParameter()))
+ if (ServerInvokerCallbackHandler.CALLBACK_ACK_PREPROCESS == preOrPost)
{
log.info("received preprocess acknowledgment");
acknowledgedPreprocess = true;
}
- else if ("postprocess".equals(callback.getParameter()))
+ else if (ServerInvokerCallbackHandler.CALLBACK_ACK_POSTPROCESS == preOrPost)
{
log.info("received postprocess acknowledgment");
acknowledgedPostprocess = true;
@@ -308,12 +495,12 @@
static class TestCallbackHandler implements InvokerCallbackHandler
{
- public static boolean receivedCallback;
+ public static int callbacksReceived;
public void handleCallback(Callback callback) throws HandleCallbackException
{
log.info("entering handleCallback()");
- receivedCallback = true;
+ callbacksReceived++;
}
}
}
More information about the jboss-cvs-commits
mailing list