[jboss-cvs] JBoss Messaging SVN: r1433 - branches/Branch_1_0/tests/src/org/jboss/test/messaging/jms

[jboss-cvs-commits at lists.jboss.org]

Author: clebert.suconic at jboss.com
Date: 2006-10-04 19:41:46 -0400 (Wed, 04 Oct 2006)
New Revision: 1433

Modified:
   branches/Branch_1_0/tests/src/org/jboss/test/messaging/jms/MessageConsumerTest.java
Log:
JBMESSAGING-591 - improving testcase

Modified: branches/Branch_1_0/tests/src/org/jboss/test/messaging/jms/MessageConsumerTest.java
===================================================================
--- branches/Branch_1_0/tests/src/org/jboss/test/messaging/jms/MessageConsumerTest.java	2006-10-04 23:34:00 UTC (rev 1432)
+++ branches/Branch_1_0/tests/src/org/jboss/test/messaging/jms/MessageConsumerTest.java	2006-10-04 23:41:46 UTC (rev 1433)
@@ -1766,47 +1766,112 @@
       latch.acquire();
    }
 
-   public void testTimeoutReceiveOnClose() throws Exception
+   /** to be used by testTimeoutReceiveOnClose */
+   private class ThreadCloser extends Thread
    {
-      if (log.isTraceEnabled()) log.trace("testTimeoutReceiveOnClose");
-      consumerConnection.start();
-      final Latch latch = new Latch();
-      final long timeToSleep = 1000;
-      Thread closerThread = new Thread(new Runnable()
-      {
-         public void run()
-         {
-            try
-            {
-               // this is needed to make sure the main thread has enough time to block
+
+       Object waitMonitor;
+       long timeToSleep;
+
+       public ThreadCloser( Object waitMonitor, long timeToSleep)
+       {
+           this.waitMonitor=waitMonitor;
+           this.timeToSleep=timeToSleep;
+       }
+
+
+       public void run()
+       {
+           try
+           {
+               log.info("(ThreadCloser)Waiting on monitor to close thread");
+               synchronized (waitMonitor)
+               {
+                   waitMonitor.wait();
+               }
+               log.info("(ThreadCloser)Notification received");
                Thread.sleep(timeToSleep);
                topicConsumer.close();
-            }
-            catch(Exception e)
-            {
+
+           }
+           catch (Exception e)
+           {
                log.error(e);
-            }
-            finally
-            {
-               latch.release();
-            }
-         }
-      }, "closing thread");
-      closerThread.start();
+               e.printStackTrace();
+           }
+       }
+   }
 
-      long t1 = System.currentTimeMillis();
-      assertNull(topicConsumer.receive(1500));
-      long elapsed = System.currentTimeMillis() - t1;
-      log.trace("timeToSleep = " + timeToSleep + " ms, elapsed = " + elapsed + " ms");
+   /** to be used by testTimeoutReceiveOnClose */
+   private class ThreadReceiver extends Thread
+   {
 
-      // make sure it didn't wait 5 seconds to return null; allow 10 ms for overhead
-      assertTrue(elapsed <= timeToSleep + 100);
+       long timeToWait;
+       Object waitMonitor;
+       long t1;
+       long t2;
+       Object receivedObject;
 
-      // wait for the closing thread to finish
-      latch.acquire();
+       public ThreadReceiver(Object waitMonitor, long timeToWait)
+       {
+           this.waitMonitor=waitMonitor;
+           this.timeToWait=timeToWait;
+       }
+
+       public void run()
+       {
+           try
+           {
+               log.info("(ThreadReceiver)Waiting on monitor to close thread");
+               synchronized(waitMonitor)
+               {
+                   waitMonitor.wait();
+               }
+               log.info("(ThreadReceiver)Notification received");
+               t1=System.currentTimeMillis();
+               receivedObject=topicConsumer.receive(timeToWait);
+               t2=System.currentTimeMillis();
+
+           }
+           catch (Exception e)
+           {
+               log.error(e);
+               e.printStackTrace();
+           }
+       }
    }
 
+  public void testTimeoutReceiveOnClose() throws Exception
+  {
+     System.gc();       /// If A GC need to be execute, it' s better to be executed now
+     Thread.sleep(1000);
+     if (log.isTraceEnabled()) log.trace("testTimeoutReceiveOnClose");
 
+     Object monitor = new Object();
+     ThreadCloser closer = null;
+     ThreadReceiver receiver = new ThreadReceiver(monitor,2000);
+
+     closer = new ThreadCloser(monitor,1000);
+     receiver= new ThreadReceiver(monitor,2000);
+     closer.start();
+     receiver.start();
+     Thread.sleep(2000);
+     synchronized (monitor)
+     {
+        monitor.notifyAll();
+     }
+     closer.join();
+     receiver.join();
+
+
+     assertNull(receiver.receivedObject);
+
+     log.info("Elapsed time was " + (receiver.t2-receiver.t1));
+
+     // We need to make sure the
+     assertTrue("Receive was supposed to receive a notification before 2 seconds",receiver.t2-receiver.t1<=1500);
+  }
+
    //
    // MessageListener tests
    //