[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