[jboss-cvs] jboss-jms/tests/src/org/jboss/test/messaging/core/paging ...

Timothy Fox tim.fox at jboss.com
Mon Jul 17 13:14:51 EDT 2006


  User: timfox  
  Date: 06/07/17 13:14:51

  Modified:    tests/src/org/jboss/test/messaging/core/paging               
                        ChannelShare_NP_2PCTest.java
                        ChannelShare_NP_NTTest.java
                        ChannelShare_NP_TTest.java
                        ChannelShare_P_2PCTest.java
                        ChannelShare_P_NTTest.java
                        ChannelShare_P_TTest.java PagingStateTestBase.java
                        PagingTest.java SingleChannel_NP_2PCTest.java
                        SingleChannel_NP_NTTest.java
                        SingleChannel_NP_TTest.java
                        SingleChannel_P_2PCTest.java
                        SingleChannel_P_NTTest.java
                        SingleChannel_P_TTest.java
                        SingleChannel_ReloadTest.java
  Log:
  Many changes including implementation of prefetch, SEDAisation of server, changing of recovery
  
  Revision  Changes    Path
  1.3       +77 -91    jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_2PCTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: ChannelShare_NP_2PCTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_2PCTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- ChannelShare_NP_2PCTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ ChannelShare_NP_2PCTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,16 +23,16 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
  -import org.jboss.messaging.core.SimpleDelivery;
   import org.jboss.messaging.core.local.Queue;
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   
   /**
    * 
  @@ -65,13 +65,9 @@
      
      public void testChannelShareNP_2PC() throws Throwable
      {
  -      Channel queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state1 = new ChannelState(queue1, pm, null, true, true, 100, 20, 10);
  -      
  -      Channel queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5);
  +      ChannelSupport queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
         
  -      ChannelState state2 = new ChannelState(queue2, pm, null, true, true, 50, 10, 5);
  +      ChannelSupport queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5, new QueuedExecutor());
                     
         Message[] msgs = new Message[150];
         
  @@ -88,11 +84,13 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -101,26 +99,26 @@
         List refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(50, state1.memoryRefCount());
  +      assertEquals(50, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -138,11 +136,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -152,26 +154,26 @@
                 
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(75, state1.memoryRefCount());
  +      assertEquals(75, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(25, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -190,11 +192,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -204,26 +210,26 @@
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(50, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -241,11 +247,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -255,26 +265,26 @@
                   
         assertEquals(50, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(100, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -283,65 +293,41 @@
         msgIds = getMessageIds();
         assertEquals(100, msgIds.size());
         
  -      //    Remove 100 then cancel
  -      SimpleDelivery[] dels1 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state1.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels1[i] = new SimpleDelivery(queue1, ref, false);
  -         state1.addDelivery(dels1[i]);
  -      }
  -      
  -      SimpleDelivery[] dels2 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state2.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels2[i] = new SimpleDelivery(queue2, ref, false);
  -         state2.addDelivery(dels2[i]);
  -      }
  +      cancelDeliveries(queue1, 100);
         
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state1.cancelDelivery(dels1[i]);
  -      }
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state2.cancelDelivery(dels2[i]);
  -      }
  +      cancelDeliveries(queue2, 100);
         
         //Now consume them all
         
  -      this.consumeIn2PCTx(queue1, state1, 0, refs1, 150);
  +      this.consumeIn2PCTx(queue1, 0, refs1, 150);
          
  -      this.consumeIn2PCTx(queue2, state2, 0, refs2, 150);
  +      this.consumeIn2PCTx(queue2, 0, refs2, 150);
         
         //    Queue1
         refIds = getReferenceIds(queue1.getChannelID());
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(0, state1.memoryRefCount());
  +      assertEquals(0, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(0, state2.memoryRefCount());
  +      assertEquals(0, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertFalse(state2.isPaging());      
  +      assertFalse(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -352,9 +338,9 @@
         
         //Should be none left
         
  -      assertNull(state1.removeFirstInMemory());
  +      assertEquals(0, queue1.messageCount());
         
  -      assertNull(state2.removeFirstInMemory());
  +      assertEquals(0, queue2.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
         
  
  
  
  1.3       +75 -86    jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_NTTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: ChannelShare_NP_NTTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_NTTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- ChannelShare_NP_NTTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ ChannelShare_NP_NTTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,15 +23,15 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
  -import org.jboss.messaging.core.SimpleDelivery;
   import org.jboss.messaging.core.local.Queue;
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   
   /**
    * 
  @@ -64,13 +64,9 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state1 = new ChannelState(queue1, pm, null, true, true, 100, 20, 10);
  -      
  -      Channel queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5);
  +      ChannelSupport queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
         
  -      ChannelState state2 = new ChannelState(queue2, pm, null, true, true, 50, 10, 5);
  +      ChannelSupport queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5, new QueuedExecutor());
                     
         Message[] msgs = new Message[150];
         
  @@ -86,37 +82,41 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
         List refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(50, state1.memoryRefCount());
  +      assertEquals(50, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -133,11 +133,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
  @@ -145,26 +149,26 @@
                 
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(75, state1.memoryRefCount());
  +      assertEquals(75, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(25, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -183,11 +187,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
  @@ -195,26 +203,26 @@
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(50, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -232,11 +240,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
  @@ -244,26 +256,26 @@
                   
         assertEquals(50, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(100, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -273,64 +285,41 @@
         assertEquals(100, msgIds.size());
         
         //Remove 100 then cancel
  -      SimpleDelivery[] dels1 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state1.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels1[i] = new SimpleDelivery(queue1, ref, false);
  -         state1.addDelivery(dels1[i]);
  -      }
  -      
  -      SimpleDelivery[] dels2 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state2.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels2[i] = new SimpleDelivery(queue2, ref, false);
  -         state2.addDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue1, 100);
         
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state1.cancelDelivery(dels1[i]);
  -      }
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state2.cancelDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue2, 100);
         
         //Now consume them all
         
  -      this.consume(queue1, state1, 0, refs1, 150);
  +      this.consume(queue1, 0, refs1, 150);
          
  -      this.consume(queue2, state2, 0, refs2, 150);
  +      this.consume(queue2, 0, refs2, 150);
         
         //    Queue1
         refIds = getReferenceIds(queue1.getChannelID());
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(0, state1.memoryRefCount());
  +      assertEquals(0, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(0, state2.memoryRefCount());
  +      assertEquals(0, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertFalse(state2.isPaging());      
  +      assertFalse(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -341,9 +330,9 @@
         
         //Should be none left
         
  -      assertNull(state1.removeFirstInMemory());
  +      assertEquals(0, queue1.messageCount());
         
  -      assertNull(state2.removeFirstInMemory());
  +      assertEquals(0, queue2.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
         
  
  
  
  1.3       +76 -87    jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_TTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: ChannelShare_NP_TTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_TTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- ChannelShare_NP_TTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ ChannelShare_NP_TTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,16 +23,16 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
  -import org.jboss.messaging.core.SimpleDelivery;
   import org.jboss.messaging.core.local.Queue;
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   
   /**
    * 
  @@ -65,13 +65,9 @@
      
      public void testChannelShareNP_Transactional() throws Throwable
      {
  -      Channel queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state1 = new ChannelState(queue1, pm, null, true, true, 100, 20, 10);
  -      
  -      Channel queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5);
  +      ChannelSupport queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
         
  -      ChannelState state2 = new ChannelState(queue2, pm, null, true, true, 50, 10, 5);
  +      ChannelSupport queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5, new QueuedExecutor());
                     
         Message[] msgs = new Message[150];
         
  @@ -88,11 +84,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -100,26 +100,26 @@
         List refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(50, state1.memoryRefCount());
  +      assertEquals(50, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -137,11 +137,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -150,26 +154,26 @@
                 
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(75, state1.memoryRefCount());
  +      assertEquals(75, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(25, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -188,11 +192,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -201,26 +209,26 @@
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(50, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -238,11 +246,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -251,26 +263,26 @@
                   
         assertEquals(50, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(100, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -280,64 +292,41 @@
         assertEquals(100, msgIds.size());
         
         //    Remove 100 then cancel
  -      SimpleDelivery[] dels1 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state1.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels1[i] = new SimpleDelivery(queue1, ref, false);
  -         state1.addDelivery(dels1[i]);
  -      }
  -      
  -      SimpleDelivery[] dels2 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state2.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels2[i] = new SimpleDelivery(queue2, ref, false);
  -         state2.addDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue1, 100);
         
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state1.cancelDelivery(dels1[i]);
  -      }
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state2.cancelDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue2, 100);
         
         //Now consume them all
         
  -      this.consumeInTx(queue1, state1, 0, refs1, 150);
  +      this.consumeInTx(queue1, 0, refs1, 150);
          
  -      this.consumeInTx(queue2, state2, 0, refs2, 150);
  +      this.consumeInTx(queue2, 0, refs2, 150);
         
         //    Queue1
         refIds = getReferenceIds(queue1.getChannelID());
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(0, state1.memoryRefCount());
  +      assertEquals(0, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(0, state2.memoryRefCount());
  +      assertEquals(0, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertFalse(state2.isPaging());      
  +      assertFalse(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -348,9 +337,9 @@
         
         //Should be none left
         
  -      assertNull(state1.removeFirstInMemory());
  +      assertEquals(0, queue1.messageCount());
         
  -      assertNull(state2.removeFirstInMemory());
  +      assertEquals(0, queue2.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
         
  
  
  
  1.3       +76 -87    jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_2PCTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: ChannelShare_P_2PCTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_2PCTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- ChannelShare_P_2PCTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ ChannelShare_P_2PCTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,16 +23,16 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
  -import org.jboss.messaging.core.SimpleDelivery;
   import org.jboss.messaging.core.local.Queue;
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   
   public class ChannelShare_P_2PCTest extends PagingStateTestBase
   {
  @@ -50,13 +50,9 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state1 = new ChannelState(queue1, pm, null, true, true, 100, 20, 10);
  -      
  -      Channel queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5);
  +      ChannelSupport queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
         
  -      ChannelState state2 = new ChannelState(queue2, pm, null, true, true, 50, 10, 5);
  +      ChannelSupport queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5, new QueuedExecutor());
                     
         Message[] msgs = new Message[150];
         
  @@ -72,11 +68,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -88,13 +88,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(50, refIds.size());
                                       
  -      assertEquals(50, state1.memoryRefCount());
  +      assertEquals(50, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -104,13 +104,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(50, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -127,11 +127,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -144,13 +148,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(75, refIds.size());
                                       
  -      assertEquals(75, state1.memoryRefCount());
  +      assertEquals(75, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -160,13 +164,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(75, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -185,11 +189,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -202,13 +210,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(100, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -218,13 +226,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(100, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -242,11 +250,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -259,13 +271,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(150, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -275,13 +287,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(150, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -291,64 +303,41 @@
         assertEquals(150, msgIds.size());
         
         //    Remove 100 then cancel
  -      SimpleDelivery[] dels1 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state1.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels1[i] = new SimpleDelivery(queue1, ref, false);
  -         state1.addDelivery(dels1[i]);
  -      }
  -      
  -      SimpleDelivery[] dels2 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state2.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels2[i] = new SimpleDelivery(queue2, ref, false);
  -         state2.addDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue1, 100);
         
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state1.cancelDelivery(dels1[i]);
  -      }
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state2.cancelDelivery(dels2[i]);
  -      }   
  +      this.cancelDeliveries(queue2, 100);
         
         //Now consume them all
         
  -      this.consumeIn2PCTx(queue1, state1, 0, refs1, 150);
  +      this.consumeIn2PCTx(queue1, 0, refs1, 150);
          
  -      this.consumeIn2PCTx(queue2, state2, 0, refs2, 150);
  +      this.consumeIn2PCTx(queue2, 0, refs2, 150);
         
         //    Queue1
         refIds = getReferenceIds(queue1.getChannelID());
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(0, state1.memoryRefCount());
  +      assertEquals(0, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(0, state2.memoryRefCount());
  +      assertEquals(0, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertFalse(state2.isPaging());      
  +      assertFalse(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -359,9 +348,9 @@
         
         //Should be none left
         
  -      assertNull(state1.removeFirstInMemory());
  +      assertEquals(0, queue1.messageCount());
         
  -      assertNull(state2.removeFirstInMemory());
  +      assertEquals(0, queue2.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
         
  
  
  
  1.3       +76 -87    jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_NTTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: ChannelShare_P_NTTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_NTTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- ChannelShare_P_NTTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ ChannelShare_P_NTTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,15 +23,15 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
  -import org.jboss.messaging.core.SimpleDelivery;
   import org.jboss.messaging.core.local.Queue;
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   
   /**
    * 
  @@ -65,13 +65,9 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state1 = new ChannelState(queue1, pm, null, true, true, 100, 20, 10);
  -      
  -      Channel queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5);
  +      ChannelSupport queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
         
  -      ChannelState state2 = new ChannelState(queue2, pm, null, true, true, 50, 10, 5);
  +      ChannelSupport queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5, new QueuedExecutor());
                     
         Message[] msgs = new Message[150];
         
  @@ -87,11 +83,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
  @@ -101,13 +101,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(50, refIds.size());
                                       
  -      assertEquals(50, state1.memoryRefCount());
  +      assertEquals(50, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -117,13 +117,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(50, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -140,11 +140,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
  @@ -155,13 +159,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(75, refIds.size());
                                       
  -      assertEquals(75, state1.memoryRefCount());
  +      assertEquals(75, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -171,13 +175,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(75, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -196,11 +200,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
  @@ -211,13 +219,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(100, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -227,13 +235,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(100, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -251,11 +259,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i]); 
  +         queue1.handle(null, refs1[i], null); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i]); 
  +         queue2.handle(null, refs2[i], null); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         
         //Queue1
  @@ -266,13 +278,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(150, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -282,13 +294,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(150, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -298,64 +310,41 @@
         assertEquals(150, msgIds.size());
         
         //    Remove 100 then cancel
  -      SimpleDelivery[] dels1 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state1.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels1[i] = new SimpleDelivery(queue1, ref, false);
  -         state1.addDelivery(dels1[i]);
  -      }
  -      
  -      SimpleDelivery[] dels2 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state2.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels2[i] = new SimpleDelivery(queue2, ref, false);
  -         state2.addDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue1, 100);
         
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state1.cancelDelivery(dels1[i]);
  -      }
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state2.cancelDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue2, 100);
         
         //Now consume them all
         
  -      this.consume(queue1, state1, 0, refs1, 150);
  +      this.consume(queue1, 0, refs1, 150);
          
  -      this.consume(queue2, state2, 0, refs2, 150);
  +      this.consume(queue2, 0, refs2, 150);
         
         //    Queue1
         refIds = getReferenceIds(queue1.getChannelID());
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(0, state1.memoryRefCount());
  +      assertEquals(0, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(0, state2.memoryRefCount());
  +      assertEquals(0, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertFalse(state2.isPaging());      
  +      assertFalse(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -366,9 +355,9 @@
         
         //Should be none left
         
  -      assertNull(state1.removeFirstInMemory());
  +      assertEquals(0, queue1.messageCount());
         
  -      assertNull(state2.removeFirstInMemory());
  +      assertEquals(0, queue2.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
         
  
  
  
  1.3       +76 -87    jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_TTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: ChannelShare_P_TTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_TTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- ChannelShare_P_TTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ ChannelShare_P_TTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,16 +23,16 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
  -import org.jboss.messaging.core.SimpleDelivery;
   import org.jboss.messaging.core.local.Queue;
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   
   /**
    * 
  @@ -65,13 +65,9 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state1 = new ChannelState(queue1, pm, null, true, true, 100, 20, 10);
  -      
  -      Channel queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5);
  +      ChannelSupport queue1 = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
         
  -      ChannelState state2 = new ChannelState(queue2, pm, null, true, true, 50, 10, 5);
  +      ChannelSupport queue2 = new Queue(2, ms, pm, null, true, 50, 10, 5, new QueuedExecutor());
                     
         Message[] msgs = new Message[150];
         
  @@ -87,11 +83,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -102,13 +102,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(50, refIds.size());
                                       
  -      assertEquals(50, state1.memoryRefCount());
  +      assertEquals(50, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -118,13 +118,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(50, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -141,11 +141,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -157,13 +161,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(75, refIds.size());
                                       
  -      assertEquals(75, state1.memoryRefCount());
  +      assertEquals(75, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -173,13 +177,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(75, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -198,11 +202,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -214,13 +222,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(100, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -230,13 +238,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(100, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -254,11 +262,15 @@
            
            refs1[i] = ms.reference(msgs[i]);
                   
  -         state1.addReference(refs1[i], tx); 
  +         queue1.handle(null, refs1[i], tx); 
  +         
  +         refs1[i].releaseMemoryReference();
            
            refs2[i] = ms.reference(msgs[i]);
            
  -         state2.addReference(refs2[i], tx); 
  +         queue2.handle(null, refs2[i], tx); 
  +         
  +         refs2[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -270,13 +282,13 @@
         refIds = getReferenceIds(queue1.getChannelID());
         assertEquals(150, refIds.size());
                                       
  -      assertEquals(100, state1.memoryRefCount());
  +      assertEquals(100, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertTrue(state1.isPaging());      
  +      assertTrue(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
  @@ -286,13 +298,13 @@
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(150, refIds.size());
                                 
  -      assertEquals(50, state2.memoryRefCount());
  +      assertEquals(50, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertTrue(state2.isPaging());      
  +      assertTrue(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -302,64 +314,41 @@
         assertEquals(150, msgIds.size());
         
         //    Remove 100 then cancel
  -      SimpleDelivery[] dels1 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state1.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels1[i] = new SimpleDelivery(queue1, ref, false);
  -         state1.addDelivery(dels1[i]);
  -      }
  -      
  -      SimpleDelivery[] dels2 = new SimpleDelivery[100];
  -      for (int i = 0; i < 100; i++)
  -      {
  -         MessageReference ref = state2.removeFirstInMemory();
  -         assertNotNull(ref);       
  -         dels2[i] = new SimpleDelivery(queue2, ref, false);
  -         state2.addDelivery(dels2[i]);
  -      }
  +      this.cancelDeliveries(queue1, 100);
         
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state1.cancelDelivery(dels1[i]);
  -      }
  -      for (int i = 99; i >=0; i--)
  -      {
  -         state2.cancelDelivery(dels2[i]);
  -      }   
  +      this.cancelDeliveries(queue2, 100);
         
         //Now consume them all
         
  -      this.consumeInTx(queue1, state1, 0, refs1, 150);
  +      this.consumeInTx(queue1, 0, refs1, 150);
          
  -      this.consumeInTx(queue2, state2, 0, refs2, 150);
  +      this.consumeInTx(queue2, 0, refs2, 150);
         
         //    Queue1
         refIds = getReferenceIds(queue1.getChannelID());
                   
         assertEquals(0, refIds.size());
                                       
  -      assertEquals(0, state1.memoryRefCount());
  +      assertEquals(0, queue1.memoryRefCount());
         
  -      assertEquals(0, state1.downCacheCount());
  +      assertEquals(0, queue1.downCacheCount());
         
  -      assertFalse(state1.isPaging());      
  +      assertFalse(queue1.isPaging());      
         
  -      assertEquals(0, state1.memoryDeliveryCount());
  +      assertEquals(0, queue1.memoryDeliveryCount());
         
         //Queue2
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                 
  -      assertEquals(0, state2.memoryRefCount());
  +      assertEquals(0, queue2.memoryRefCount());
         
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertFalse(state2.isPaging());      
  +      assertFalse(queue2.isPaging());      
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertEquals(0, queue2.memoryDeliveryCount());
               
         //Msgs
         
  @@ -370,9 +359,9 @@
         
         //Should be none left
         
  -      assertNull(state1.removeFirstInMemory());
  +      assertEquals(0, queue1.messageCount());
         
  -      assertNull(state2.removeFirstInMemory());
  +      assertEquals(0, queue2.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
         
  
  
  
  1.4       +261 -39   jboss-jms/tests/src/org/jboss/test/messaging/core/paging/PagingStateTestBase.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: PagingStateTestBase.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/PagingStateTestBase.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -b -r1.3 -r1.4
  --- PagingStateTestBase.java	2 May 2006 02:44:45 -0000	1.3
  +++ PagingStateTestBase.java	17 Jul 2006 17:14:51 -0000	1.4
  @@ -35,9 +35,11 @@
   import org.jboss.jms.server.plugin.JDBCChannelMapper;
   import org.jboss.messaging.core.Channel;
   import org.jboss.messaging.core.Delivery;
  +import org.jboss.messaging.core.DeliveryObserver;
   import org.jboss.messaging.core.MessageReference;
  +import org.jboss.messaging.core.Receiver;
  +import org.jboss.messaging.core.Routable;
   import org.jboss.messaging.core.SimpleDelivery;
  -import org.jboss.messaging.core.State;
   import org.jboss.messaging.core.plugin.JDBCPersistenceManager;
   import org.jboss.messaging.core.plugin.SimpleMessageStore;
   import org.jboss.messaging.core.plugin.contract.PersistenceManager;
  @@ -142,58 +144,278 @@
         }
      }
      
  +   class ConsumingReceiver implements Receiver
  +   {
  +      int numToConsume;
   
  -   protected void consume(Channel channel, State state, int consumeCount,
  -         MessageReference[] refs, int num)
  -      throws Throwable
  +      int count;
  +      
  +      MessageReference[] refs;
  +      
  +      int consumeCount;
  +      
  +      boolean xa;
  +      
  +      boolean tx;
  +      
  +      SimpleDelivery[] dels;
  +      
  +      ConsumingReceiver(int numToConsume, MessageReference[] refs, int consumeCount, boolean tx, boolean xa)
  +         throws Exception
  +      {
  +         this.numToConsume = numToConsume;
  +         
  +         this.refs = refs;
  +         
  +         this.consumeCount = consumeCount;
  +         
  +         this.xa = xa;
  +         
  +         this.tx = tx;
  +         
  +         this.dels = new SimpleDelivery[numToConsume];
  +      }
  +
  +      public synchronized Delivery handle(DeliveryObserver observer, Routable routable, Transaction tx)
      {
  -      for (int i = 0; i < num; i++)
  +         if (count >= numToConsume)
         {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertNotNull(ref.getMessage());
  -         assertEquals(refs[consumeCount + i].getMessageID(), ref.getMessageID());
  -         Delivery del = new SimpleDelivery(channel, ref, false);
  -         state.addDelivery(del);
  -         state.acknowledge(del);
  +            return null;
         }
  +         
  +         MessageReference ref = (MessageReference)routable;
  +         
  +         assertEquals(refs[consumeCount + count].getMessageID(), ref.getMessageID());
  +         
  +         SimpleDelivery del = new SimpleDelivery(observer, ref);
  +         
  +         dels[count] = del;
  +         
  +         count++;
  +         
  +         if (count == numToConsume)
  +         {
  +            notify();
      }
      
  -   protected void consumeInTx(Channel channel, State state, int consumeCount,
  -         MessageReference[] refs, int num)
  -      throws Throwable
  +         return del;                 
  +      }      
  +      
  +      void acknowledge() throws Throwable
  +      {
  +         //Wait for them all to arrive first
  +         
  +         synchronized (this)
  +         {
  +         
  +            while (count < numToConsume)
  +            {
  +               wait(10000);
  +      
  +               if (count < numToConsume)
  +               {
  +                  PagingStateTestBase.fail();
  +                  return;
  +               }
  +            }
  +         }
  +         
  +         Transaction theTx = null;
  +         
  +         if (tx)
  +         {
  +            if (xa)
  +            {
  +               theTx = createXATx();
  +            }
  +            else
  +            {
  +               theTx = tr.createTransaction();
  +            }
  +         }
  +         
  +         for (int i = 0; i < numToConsume; i++)
  +         {
  +            dels[i].acknowledge(theTx);
  +         }
  +         
  +         if (tx)
  +         {
  +            if (xa)
  +            {
  +               theTx.prepare();
  +               theTx.commit();
  +            }
  +            else
  +            {
  +               theTx.commit();
  +            }
  +         }
  +         
  +         
  +      }
  +   }
  +   
  +   class CancellingReceiver implements Receiver
  +   {
  +      int numToCancel;
  +      
  +      int count;
  +        
  +      SimpleDelivery[] toCancel;
  +      
  +      CancellingReceiver(int numToConsume)
  +         throws Exception
  +      {
  +         this.numToCancel = numToConsume;
  +         
  +         this.toCancel = new SimpleDelivery[numToCancel];
  +         
  +      }
  +
  +      public synchronized Delivery handle(DeliveryObserver observer, Routable routable, Transaction tx)
  +      {
  +         if (count == numToCancel)
  +         {
  +            return null;
  +         }
  +         
  +         MessageReference ref = (MessageReference)routable;
  +         
  +         SimpleDelivery del = new SimpleDelivery(observer, ref);
  +         
  +         toCancel[count] = del;                  
  +         
  +         count++;         
  +         
  +         if (count == numToCancel)
      {
  -      Transaction tx = tr.createTransaction();
  -      for (int i = 0; i < num; i++)
  +            notify();
  +         }
  +         
  +         return del;
  +                  
  +      }      
  +      
  +      public synchronized SimpleDelivery[] getToCancel() throws Exception
  +      {
  +         // Wait for them all to arrive first
  +         
  +         while (count < numToCancel)
         {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertNotNull(ref.getMessage());
  -         assertEquals(refs[consumeCount + i].getMessageID(), ref.getMessageID());
  -         Delivery del = new SimpleDelivery(channel, ref, false);
  -         state.addDelivery(del);
  -         state.acknowledge(del, tx);
  +            wait(1000);
  +            
  +            if (count < numToCancel)
  +            {
  +               PagingStateTestBase.fail();
  +               return null;
         }
  -      tx.commit();
      }
      
  -   protected void consumeIn2PCTx(Channel channel, State state, int consumeCount,
  +         return toCancel;
  +         
  +      }
  +      
  +      void cancel() throws Exception
  +      {
  +         //Wait for them all to arrive first
  +         
  +         synchronized (this)
  +         {
  +            
  +            while (count < numToCancel)
  +            {
  +               wait(1000);
  +               
  +               if (count < numToCancel)
  +               {
  +                  PagingStateTestBase.fail();
  +                  return;
  +               }
  +            }
  +         }
  +         
  +         for (int i = numToCancel - 1; i >=0; i--)
  +         {
  +            try
  +            {
  +               toCancel[i].cancel();
  +            }
  +            catch (Throwable t)
  +            {
  +               log.error("Failed to cancel", t);
  +               PagingStateTestBase.fail();
  +            }
  +         }
  +      }
  +   }
  +
  +   protected void consume(Channel channel, int consumeCount,
            MessageReference[] refs, int num)
         throws Throwable
      {
  -      Transaction tx = createXATx();
  -      for (int i = 0; i < num; i++)
  +      ConsumingReceiver r = new ConsumingReceiver(num, refs, consumeCount, false, false);
  +      channel.add(r);
  +      channel.deliver(false);
  +      r.acknowledge();
  +      channel.remove(r);
  +      //Need to give enough time for the call to handle to complete and return
  +      //thus removing the ref
  +      Thread.sleep(500);
  +   }
  +   
  +   protected void consumeInTx(Channel channel, int consumeCount,
  +         MessageReference[] refs, int num)
  +      throws Throwable
         {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertNotNull(ref.getMessage());
  -         assertEquals(refs[consumeCount + i].getMessageID(), ref.getMessageID());
  -         Delivery del = new SimpleDelivery(channel, ref, false);
  -         state.addDelivery(del);
  -         state.acknowledge(del, tx);
  +      ConsumingReceiver r = new ConsumingReceiver(num, refs, consumeCount, true, false);
  +      channel.add(r);
  +      channel.deliver(false);
  +      r.acknowledge();
  +      channel.remove(r);
  +      //Need to give enough time for the call to handle to complete and return
  +      //thus removing the ref
  +      Thread.sleep(500);
         }
  -      tx.prepare();
  -      tx.commit();
  +   
  +   protected void consumeIn2PCTx(Channel channel, int consumeCount,
  +         MessageReference[] refs, int num)
  +      throws Throwable
  +   {
  +      ConsumingReceiver r = new ConsumingReceiver(num, refs, consumeCount, true, true);
  +      channel.add(r);
  +      channel.deliver(false);
  +      r.acknowledge();
  +      channel.remove(r);
  +      //Need to give enough time for the call to handle to complete and return
  +      //thus removing the ref
  +      Thread.sleep(500);
  +   }
  +   
  +   protected SimpleDelivery[] getDeliveries(Channel channel, int number) throws Exception
  +   {
  +      CancellingReceiver r1 = new CancellingReceiver(number);
  +      channel.add(r1);
  +      channel.deliver(false);   
  +      SimpleDelivery[] dels = r1.getToCancel();
  +      channel.remove(r1);
  +      //Need to give enough time for the call to handle to complete and return
  +      //thus removing the ref
  +      Thread.sleep(500);      
  +      
  +      return dels;
  +   }
  +   
  +   protected void cancelDeliveries(Channel channel, int number) throws Exception
  +   {
  +      CancellingReceiver r1 = new CancellingReceiver(number);
  +      channel.add(r1);
  +      channel.deliver(false);   
  +      r1.cancel();
  +      channel.remove(r1);
  +      //Need to give enough time for the call to handle to complete and return
  +      //thus removing the ref
  +      Thread.sleep(500);      
      }
      
      
  
  
  
  1.6       +5 -3      jboss-jms/tests/src/org/jboss/test/messaging/core/paging/PagingTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: PagingTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/PagingTest.java,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -b -r1.5 -r1.6
  --- PagingTest.java	27 Jun 2006 19:44:41 -0000	1.5
  +++ PagingTest.java	17 Jul 2006 17:14:51 -0000	1.6
  @@ -31,12 +31,14 @@
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.local.Pipe;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   
   /**
    * @author <a href="mailto:ovidiu at jboss.org">Ovidiu Feodorov</a>
  - * @version <tt>$Revision: 1.5 $</tt>
  + * @version <tt>$Revision: 1.6 $</tt>
    *
  - * $Id: PagingTest.java,v 1.5 2006/06/27 19:44:41 timfox Exp $
  + * $Id: PagingTest.java,v 1.6 2006/07/17 17:14:51 timfox Exp $
    */
   public class PagingTest extends MessagingTestCase
   {
  @@ -62,7 +64,7 @@
      public void testPaging() throws Exception
      {
   
  -      Pipe p = new Pipe(0, ms, pm, null, true, true, 100, 20, 10);
  +      Pipe p = new Pipe(0, ms, pm, null, true, true, 100, 20, 10, new QueuedExecutor());
         CoreMessage m = null;
   
         m = MessageFactory.createCoreMessage(0);
  
  
  
  1.3       +141 -139  jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_2PCTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: SingleChannel_NP_2PCTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_2PCTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- SingleChannel_NP_2PCTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ SingleChannel_NP_2PCTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,8 +23,7 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
   import org.jboss.messaging.core.SimpleDelivery;
  @@ -33,6 +32,8 @@
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   /**
    * 
    * A PagingTest_NP_2PC_Recoverable.
  @@ -66,9 +67,7 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state = new ChannelState(queue, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
                          
         Message[] msgs = new Message[241];
         
  @@ -83,7 +82,9 @@
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
                   
  -         state.addReference(refs[i], tx); 
  +         queue.handle(null, refs[i], tx); 
  +         
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -101,16 +102,16 @@
         assertEquals(99, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         //Send one more ref
  @@ -119,7 +120,8 @@
         
         msgs[99] = MessageFactory.createCoreMessage(99, false, null);
         refs[99] = ms.reference(msgs[99]);
  -      state.addReference(refs[99], tx);
  +      queue.handle(null, refs[99], tx);
  +      refs[99].releaseMemoryReference();
         
         tx.prepare();
         tx.commit();
  @@ -137,16 +139,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
               
         //Verify paging
  -      assertTrue(state.isPaging());
  +      assertTrue(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         //Send 9 more
  @@ -156,7 +158,8 @@
         {         
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);         
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -174,16 +177,16 @@
         assertEquals(109, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 9 refs in downcache
  -      assertEquals(9, state.downCacheCount());
  +      assertEquals(9, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -193,7 +196,8 @@
         tx = createXATx();
         msgs[109] = MessageFactory.createCoreMessage(109, false, null);
         refs[109] = ms.reference(msgs[109]);
  -      state.addReference(refs[109], tx);
  +      queue.handle(null, refs[109], tx);
  +      refs[109].releaseMemoryReference();
         tx.prepare();
         tx.commit();
         
  @@ -212,16 +216,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -230,7 +234,8 @@
         tx = createXATx();
         msgs[110] = MessageFactory.createCoreMessage(110, false, null);
         refs[110] = ms.reference(msgs[110]);
  -      state.addReference(refs[110], tx);
  +      queue.handle(null, refs[110], tx);
  +      refs[110].releaseMemoryReference();
         tx.prepare();
         tx.commit();
         
  @@ -249,16 +254,16 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -269,7 +274,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);         
  +         refs[i].releaseMemoryReference();
         }      
         tx.prepare();
         tx.commit();
  @@ -289,16 +295,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         //    Send 100 more refs then roll back
         tx = this.createXATx();
  @@ -306,7 +312,8 @@
         {
            Message m = MessageFactory.createCoreMessage(i, true, null);
            MessageReference ref = ms.reference(m);
  -         state.addReference(ref, tx);         
  +         queue.handle(null, ref, tx);        
  +         ref.releaseMemoryReference();
         }  
         tx.prepare();
         tx.rollback();
  @@ -319,7 +326,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);  
  +         refs[i].releaseMemoryReference();
         }  
         tx.prepare();
         tx.commit();
  @@ -339,16 +347,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -360,7 +368,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx); 
  +         refs[i].releaseMemoryReference();
         }  
         tx.prepare();
         tx.commit();
  @@ -380,16 +389,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
   
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -399,7 +408,8 @@
         tx = createXATx();
         msgs[140] = MessageFactory.createCoreMessage(140, false, null);
         refs[140] = ms.reference(msgs[140]);
  -      state.addReference(refs[140], tx);
  +      queue.handle(null, refs[140], tx);
  +      refs[140].releaseMemoryReference();
         tx.prepare();
         tx.commit();
         
  @@ -418,23 +428,23 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
                   
         
         
         //Consume 1
         int consumeCount = 0;
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 1);
  +      consumeIn2PCTx(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //verify 40 refs in storage
  @@ -452,16 +462,16 @@
         assertEquals(100, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -469,7 +479,7 @@
         //Now we should have 99 refs in memory, 40 refs in storage, and 1 in down cache, 100 msgs in memory
         
         //Consume 18 more
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 18);
  +      consumeIn2PCTx(queue, consumeCount, refs, 18);
         consumeCount += 18;
         
         //We should have 81 refs in memory, 40 refs in storage, and 1 in down cache, 82 msgs in memory
  @@ -489,23 +499,21 @@
         assertEquals(82, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(81, state.memoryRefCount());
  +      assertEquals(81, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  -            
  -      
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         //Consume one more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 1);
  +      consumeIn2PCTx(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //This should force a load of 20 and flush the downcache
  @@ -525,23 +533,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 20 more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 20);
  +      consumeIn2PCTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 1 ref in storage
  @@ -559,23 +567,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 1 more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 1);
  +      consumeIn2PCTx(queue, consumeCount, refs, 1);
         consumeCount ++;
         
         //verify 0 ref in storage
  @@ -591,23 +599,23 @@
         assertEquals(100, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume 20 more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 20);
  +      consumeIn2PCTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 0 ref in storage
  @@ -623,23 +631,23 @@
         assertEquals(80, ms.size());
         
         //Verify 80 refs in queue
  -      assertEquals(80, state.memoryRefCount());
  +      assertEquals(80, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         //Consumer 60 more
         
               
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 60);
  +      consumeIn2PCTx(queue, consumeCount, refs, 60);
         consumeCount += 60;
         
         //verify 0 ref in storage
  @@ -655,16 +663,16 @@
         assertEquals(20, ms.size());
         
         //Verify 20 refs in queue
  -      assertEquals(20, state.memoryRefCount());
  +      assertEquals(20, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -674,7 +682,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -692,16 +701,16 @@
         assertEquals(40, ms.size());
         
         //Verify 40 refs in queue
  -      assertEquals(40, state.memoryRefCount());
  +      assertEquals(40, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -712,7 +721,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -730,16 +740,16 @@
         assertEquals(60, ms.size());
         
         //Verify 60 refs in queue
  -      assertEquals(60, state.memoryRefCount());
  +      assertEquals(60, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -749,7 +759,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -769,16 +780,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
          
  @@ -787,15 +798,7 @@
         //remove 20 but don't ack them yet
         //this should cause a load to be triggered
         
  -      SimpleDelivery[] dels = new SimpleDelivery[20];
  -      for (int i = 0; i < 20; i++)
  -      {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertEquals(refs[i + consumeCount].getMessageID(), ref.getMessageID());
  -         dels[i] = new SimpleDelivery(queue, ref, false);
  -         state.addDelivery(dels[i]);
  -      }
  +      SimpleDelivery[] dels = this.getDeliveries(queue, 20);
         
         //verify 0 ref in storage
         
  @@ -810,20 +813,20 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 20 deliveries
  -      assertEquals(20, state.memoryDeliveryCount());;      
  +      assertEquals(20, queue.memoryDeliveryCount());;      
         
         
          
         //Cancel last 7
         for (int i = 19; i > 12; i--)
         {
  -         state.cancelDelivery(dels[i]);   
  +         dels[i].cancel();   
         }
         
         //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
  @@ -842,13 +845,13 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 13 deliveries
  -      assertEquals(13, state.memoryDeliveryCount());;      
  +      assertEquals(13, queue.memoryDeliveryCount());;      
         
         
      
  @@ -856,7 +859,7 @@
         
         for (int i = 12; i > 9; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //This should cause the down cache to be flushed
  @@ -876,13 +879,13 @@
         assertEquals(110, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 10 deliveries
  -      assertEquals(10, state.memoryDeliveryCount());;      
  +      assertEquals(10, queue.memoryDeliveryCount());;      
         
               
         
  @@ -890,7 +893,7 @@
         
         for (int i = 9; i >= 0; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         
  @@ -911,20 +914,20 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
         //Now there should be 120 message left to consume
         
         //Consume 50
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 50);
  +      consumeIn2PCTx(queue, consumeCount, refs, 50);
         consumeCount += 50;
         
         //verify 0 ref in storage
  @@ -940,18 +943,18 @@
         assertEquals(70, ms.size());
         
         //Verify 70 refs in queue
  -      assertEquals(70, state.memoryRefCount());  
  +      assertEquals(70, queue.memoryRefCount());  
         
         //Verify not paging
  -      assertFalse(state.isPaging());      
  +      assertFalse(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
                     
         //Consume the rest
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 70);
  +      consumeIn2PCTx(queue, consumeCount, refs, 70);
         consumeCount += 70;
         
         //verify 0 ref in storage
  @@ -967,13 +970,12 @@
         assertEquals(0, ms.size());
         
         //Verify 0 refs in queue
  -      assertEquals(0, state.memoryRefCount());
  +      assertEquals(0, queue.memoryRefCount());
         
  -      //Make sure there are no more refs in state
  +      //Make sure there are no more refs in queue
         
  -      MessageReference ref = state.removeFirstInMemory();
  +      assertEquals(0, queue.messageCount());
         
  -      assertNull(ref);
         assertEquals(0, LockMap.instance.getSize());
         
      
  
  
  
  1.3       +147 -140  jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_NTTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: SingleChannel_NP_NTTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_NTTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- SingleChannel_NP_NTTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ SingleChannel_NP_NTTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,8 +23,7 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
   import org.jboss.messaging.core.SimpleDelivery;
  @@ -32,6 +31,8 @@
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   /**
    * 
    * A PagingTest_NP_NT_Recoverable.
  @@ -65,9 +66,7 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state = new ChannelState(queue, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
                          
         Message[] msgs = new Message[241];
         
  @@ -79,7 +78,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         //verify no refs in storage
  @@ -95,23 +95,24 @@
         assertEquals(99, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         //Send one more ref
         
         msgs[99] = MessageFactory.createCoreMessage(99, false, null);
         refs[99] = ms.reference(msgs[99]);
  -      state.addReference(refs[99]);
  +      queue.handle(null, refs[99], null);
  +      refs[99].releaseMemoryReference();
         
         //verify no refs in storage
         
  @@ -126,16 +127,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
               
         //Verify paging
  -      assertTrue(state.isPaging());
  +      assertTrue(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
                     
         //Send 9 more
         
  @@ -143,7 +144,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]); 
  +         queue.handle(null, refs[i], null); 
  +         refs[i].releaseMemoryReference();
         }
         
         //verify no refs in storage
  @@ -159,16 +161,16 @@
         assertEquals(109, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 9 refs in downcache
  -      assertEquals(9, state.downCacheCount());
  +      assertEquals(9, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -177,7 +179,8 @@
         
         msgs[109] = MessageFactory.createCoreMessage(109, false, null);
         refs[109] = ms.reference(msgs[109]);
  -      state.addReference(refs[109]);
  +      queue.handle(null, refs[109], null);
  +      refs[109].releaseMemoryReference();
         
         //verify 10 refs in storage
         
  @@ -194,16 +197,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -211,7 +214,8 @@
         
         msgs[110] = MessageFactory.createCoreMessage(110, false, null);
         refs[110] = ms.reference(msgs[110]);
  -      state.addReference(refs[110]);
  +      queue.handle(null, refs[110], null);
  +      refs[110].releaseMemoryReference();
         
         //verify 10 refs in storage
         
  @@ -228,16 +232,16 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -247,7 +251,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);         
  +         refs[i].releaseMemoryReference();
         }      
         
         //verify 20 refs in storage
  @@ -265,16 +270,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -285,7 +290,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);         
  +         refs[i].releaseMemoryReference();
         }  
         
         //verify 30 refs in storage
  @@ -303,16 +309,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -323,7 +329,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);         
  +         refs[i].releaseMemoryReference();
         }  
         
         //verify 40 refs in storage
  @@ -341,16 +348,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
   
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -359,7 +366,8 @@
         
         msgs[140] = MessageFactory.createCoreMessage(140, false, null);
         refs[140] = ms.reference(msgs[140]);
  -      state.addReference(refs[140]);
  +      queue.handle(null, refs[140], null);
  +      refs[140].releaseMemoryReference();
         
         //verify 40 refs in storage
         
  @@ -376,23 +384,23 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
                   
         
         
         //Consume 1
         int consumeCount = 0;
  -      consume(queue, state, consumeCount, refs, 1);
  +      consume(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //verify 40 refs in storage
  @@ -410,16 +418,16 @@
         assertEquals(100, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -427,7 +435,7 @@
         //Now we should have 99 refs in memory, 40 refs in storage, and 1 in down cache, 100 msgs in memory
         
         //Consume 18 more
  -      consume(queue, state, consumeCount, refs, 18);
  +      consume(queue, consumeCount, refs, 18);
         consumeCount += 18;
         
         //We should have 81 refs in memory, 40 refs in storage, and 1 in down cache, 82 msgs in memory
  @@ -447,23 +455,23 @@
         assertEquals(82, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(81, state.memoryRefCount());
  +      assertEquals(81, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume one more
         
  -      consume(queue, state, consumeCount, refs, 1);
  +      consume(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //This should force a load of 20 and flush the downcache
  @@ -484,23 +492,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 20 more
         
  -      consume(queue, state, consumeCount, refs, 20);
  +      consume(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 1 ref in storage
  @@ -518,23 +526,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 1 more
         
  -      consume(queue, state, consumeCount, refs, 1);
  +      consume(queue, consumeCount, refs, 1);
         consumeCount ++;
         
         //verify 0 ref in storage
  @@ -550,23 +558,23 @@
         assertEquals(100, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume 20 more
         
  -      consume(queue, state, consumeCount, refs, 20);
  +      consume(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 0 ref in storage
  @@ -582,23 +590,23 @@
         assertEquals(80, ms.size());
         
         //Verify 80 refs in queue
  -      assertEquals(80, state.memoryRefCount());
  +      assertEquals(80, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         //Consumer 60 more
         
               
  -      consume(queue, state, consumeCount, refs, 60);
  +      consume(queue, consumeCount, refs, 60);
         consumeCount += 60;
         
         //verify 0 ref in storage
  @@ -614,16 +622,16 @@
         assertEquals(20, ms.size());
         
         //Verify 20 refs in queue
  -      assertEquals(20, state.memoryRefCount());
  +      assertEquals(20, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -632,7 +640,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         //verify 0 ref in storage
  @@ -648,16 +657,16 @@
         assertEquals(40, ms.size());
         
         //Verify 40 refs in queue
  -      assertEquals(40, state.memoryRefCount());
  +      assertEquals(40, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -667,7 +676,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         //verify 0 ref in storage
  @@ -683,16 +693,16 @@
         assertEquals(60, ms.size());
         
         //Verify 60 refs in queue
  -      assertEquals(60, state.memoryRefCount());
  +      assertEquals(60, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -701,7 +711,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         //verify 20 ref in storage
  @@ -719,16 +730,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
          
  @@ -737,15 +748,9 @@
         //remove 20 but don't ack them yet
         //this should cause a load to be triggered
         
  -      SimpleDelivery[] dels = new SimpleDelivery[20];
  -      for (int i = 0; i < 20; i++)
  -      {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertEquals(refs[i + consumeCount].getMessageID(), ref.getMessageID());
  -         dels[i] = new SimpleDelivery(queue, ref, false);
  -         state.addDelivery(dels[i]);
  -      }
  +//      CancellingReceiver r = new CancellingReceiver(20);
  +//      queue.add(r);
  +      SimpleDelivery[] dels = getDeliveries(queue, 20);
         
         //verify 0 ref in storage
         
  @@ -760,20 +765,20 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 20 deliveries
  -      assertEquals(20, state.memoryDeliveryCount());;      
  +      assertEquals(20, queue.memoryDeliveryCount());;      
         
         
          
         //Cancel last 7
         for (int i = 19; i > 12; i--)
         {
  -         state.cancelDelivery(dels[i]);   
  +         dels[i].cancel();  
         }
         
         //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
  @@ -792,13 +797,13 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 13 deliveries
  -      assertEquals(13, state.memoryDeliveryCount());;      
  +      assertEquals(13, queue.memoryDeliveryCount());;      
         
         
      
  @@ -806,7 +811,7 @@
         
         for (int i = 12; i > 9; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //This should cause the down cache to be flushed
  @@ -826,13 +831,13 @@
         assertEquals(110, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 10 deliveries
  -      assertEquals(10, state.memoryDeliveryCount());;      
  +      assertEquals(10, queue.memoryDeliveryCount());;      
         
               
         
  @@ -840,7 +845,7 @@
         
         for (int i = 9; i >= 0; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //consumeCount += 20;
  @@ -862,22 +867,22 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  -      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
  +      assertEquals(0, queue.downCacheCount());
   
   
         //Now there should be 120 message left to consume
         
         //Consume 50
         
  -      consume(queue, state, consumeCount, refs, 50);
  +      consume(queue, consumeCount, refs, 50);
         consumeCount += 50;
         
         //verify 0 ref in storage
  @@ -892,21 +897,25 @@
         //Verify 70 msgs in store
         assertEquals(70, ms.size());
         
  +      //Verify 0 deliveries
  +      assertEquals(0, queue.memoryDeliveryCount());
  +      
  +      assertEquals(0, queue.downCacheCount());
  +                  
         //Verify 70 refs in queue
  -      assertEquals(70, state.memoryRefCount());  
  +      assertEquals(70, queue.memoryRefCount());  
  +      
  +//    Verify not paging
  +      assertFalse(queue.isPaging());      
         
  -      //Verify not paging
  -      assertFalse(state.isPaging());      
         
  -      //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
         
         
         
         
         //Consume the rest
         
  -      consume(queue, state, consumeCount, refs, 70);
  +      consume(queue, consumeCount, refs, 70);
         consumeCount += 70;
         
         //verify 0 ref in storage
  @@ -922,13 +931,11 @@
         assertEquals(0, ms.size());
         
         //Verify 0 refs in queue
  -      assertEquals(0, state.memoryRefCount());
  -      
  -      //Make sure there are no more refs in state
  +      assertEquals(0, queue.memoryRefCount());
         
  -      MessageReference ref = state.removeFirstInMemory();
  +      //Make sure there are no more refs in queue
         
  -      assertNull(ref);
  +      assertEquals(0, queue.messageCount());
            
         assertEquals(0, LockMap.instance.getSize());
      }
  
  
  
  1.3       +139 -136  jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_TTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: SingleChannel_NP_TTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_TTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- SingleChannel_NP_TTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ SingleChannel_NP_TTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,8 +23,7 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
   import org.jboss.messaging.core.SimpleDelivery;
  @@ -33,6 +32,8 @@
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   /**
    * 
    * A PagingTest_NP_T_Recoverable.
  @@ -66,9 +67,7 @@
    
      public void test1() throws Throwable
      {
  -      Channel queue = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state = new ChannelState(queue, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
                          
         Message[] msgs = new Message[241];
         
  @@ -83,7 +82,8 @@
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
                   
  -         state.addReference(refs[i], tx); 
  +         queue.handle(null, refs[i], tx); 
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -100,16 +100,16 @@
         assertEquals(99, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         //Send one more ref
  @@ -118,7 +118,8 @@
         
         msgs[99] = MessageFactory.createCoreMessage(99, false, null);
         refs[99] = ms.reference(msgs[99]);
  -      state.addReference(refs[99], tx);
  +      queue.handle(null, refs[99], tx);
  +      refs[99].releaseMemoryReference();
         
         tx.commit();
         
  @@ -135,16 +136,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
               
         //Verify paging
  -      assertTrue(state.isPaging());
  +      assertTrue(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         //Send 9 more
  @@ -154,7 +155,8 @@
         {         
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx); 
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -171,16 +173,16 @@
         assertEquals(109, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 9 refs in downcache
  -      assertEquals(9, state.downCacheCount());
  +      assertEquals(9, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -190,7 +192,8 @@
         tx = tr.createTransaction();
         msgs[109] = MessageFactory.createCoreMessage(109, false, null);
         refs[109] = ms.reference(msgs[109]);
  -      state.addReference(refs[109], tx);
  +      queue.handle(null, refs[109], tx);
  +      refs[109].releaseMemoryReference();
         tx.commit();
         
         //verify 10 refs in storage
  @@ -208,16 +211,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -226,7 +229,8 @@
         tx = tr.createTransaction();
         msgs[110] = MessageFactory.createCoreMessage(110, false, null);
         refs[110] = ms.reference(msgs[110]);
  -      state.addReference(refs[110], tx);
  +      queue.handle(null, refs[110], tx);
  +      refs[110].releaseMemoryReference();
         tx.commit();
         
         //verify 10 refs in storage
  @@ -244,16 +248,16 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -264,7 +268,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);         
  +         refs[i].releaseMemoryReference();
         }      
         tx.commit();
         
  @@ -283,16 +288,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         //Send 100 more refs then roll back
         tx = tr.createTransaction();
  @@ -301,7 +306,8 @@
         {
            Message m = MessageFactory.createCoreMessage(i, true, null);
            MessageReference ref = ms.reference(m);
  -         state.addReference(ref, tx);         
  +         queue.handle(null, ref, tx);     
  +         ref.releaseMemoryReference();
         }  
         tx.rollback();
      
  @@ -313,7 +319,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);         
  +         refs[i].releaseMemoryReference();
         }  
         tx.commit();
         
  @@ -332,16 +339,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -353,7 +360,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);      
  +         refs[i].releaseMemoryReference();
         }  
         tx.commit();
         
  @@ -372,16 +380,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
   
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -391,7 +399,8 @@
         tx = tr.createTransaction();
         msgs[140] = MessageFactory.createCoreMessage(140, false, null);
         refs[140] = ms.reference(msgs[140]);
  -      state.addReference(refs[140], tx);
  +      queue.handle(null, refs[140], tx);
  +      refs[140].releaseMemoryReference();
         tx.commit();
         
         //verify 40 refs in storage
  @@ -409,23 +418,23 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
                   
         
         
         //Consume 1
         int consumeCount = 0;
  -      consumeInTx(queue, state, consumeCount, refs, 1);
  +      consumeInTx(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //verify 40 refs in storage
  @@ -443,16 +452,16 @@
         assertEquals(100, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -460,7 +469,7 @@
         //Now we should have 99 refs in memory, 40 refs in storage, and 1 in down cache, 100 msgs in memory
         
         //Consume 18 more
  -      consumeInTx(queue, state, consumeCount, refs, 18);
  +      consumeInTx(queue, consumeCount, refs, 18);
         consumeCount += 18;
         
         //We should have 81 refs in memory, 40 refs in storage, and 1 in down cache, 100 msgs in memory
  @@ -480,23 +489,23 @@
         assertEquals(82, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(81, state.memoryRefCount());
  +      assertEquals(81, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume one more
         
  -      consumeInTx(queue, state, consumeCount, refs, 1);
  +      consumeInTx(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //This should force a load of 20 and flush the downcache
  @@ -516,23 +525,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 20 more
         
  -      consumeInTx(queue, state, consumeCount, refs, 20);
  +      consumeInTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 1 ref in storage
  @@ -550,23 +559,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 1 more
         
  -      consumeInTx(queue, state, consumeCount, refs, 1);
  +      consumeInTx(queue, consumeCount, refs, 1);
         consumeCount ++;
         
         //verify 0 ref in storage
  @@ -582,23 +591,23 @@
         assertEquals(100, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume 20 more
         
  -      consumeInTx(queue, state, consumeCount, refs, 20);
  +      consumeInTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 0 ref in storage
  @@ -614,23 +623,23 @@
         assertEquals(80, ms.size());
         
         //Verify 80 refs in queue
  -      assertEquals(80, state.memoryRefCount());
  +      assertEquals(80, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         //Consumer 60 more
         
               
  -      consumeInTx(queue, state, consumeCount, refs, 60);
  +      consumeInTx(queue, consumeCount, refs, 60);
         consumeCount += 60;
         
         //verify 0 ref in storage
  @@ -646,16 +655,16 @@
         assertEquals(20, ms.size());
         
         //Verify 20 refs in queue
  -      assertEquals(20, state.memoryRefCount());
  +      assertEquals(20, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -665,7 +674,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -682,16 +692,16 @@
         assertEquals(40, ms.size());
         
         //Verify 40 refs in queue
  -      assertEquals(40, state.memoryRefCount());
  +      assertEquals(40, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -702,7 +712,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -719,16 +730,16 @@
         assertEquals(60, ms.size());
         
         //Verify 60 refs in queue
  -      assertEquals(60, state.memoryRefCount());
  +      assertEquals(60, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -738,7 +749,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, false, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -757,16 +769,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
          
  @@ -775,15 +787,8 @@
         //remove 20 but don't ack them yet
         //this should cause a load to be triggered
         
  -      SimpleDelivery[] dels = new SimpleDelivery[20];
  -      for (int i = 0; i < 20; i++)
  -      {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertEquals(refs[i + consumeCount].getMessageID(), ref.getMessageID());
  -         dels[i] = new SimpleDelivery(queue, ref, false);
  -         state.addDelivery(dels[i]);
  -      }
  +      SimpleDelivery[] dels = getDeliveries(queue, 20);
  +      
         
         //verify 0 ref in storage
         
  @@ -798,20 +803,20 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 20 deliveries
  -      assertEquals(20, state.memoryDeliveryCount());;      
  +      assertEquals(20, queue.memoryDeliveryCount());;      
         
         
          
         //Cancel last 7
         for (int i = 19; i > 12; i--)
         {
  -         state.cancelDelivery(dels[i]);   
  +         dels[i].cancel();  
         }
         
         //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
  @@ -830,13 +835,13 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 13 deliveries
  -      assertEquals(13, state.memoryDeliveryCount());;      
  +      assertEquals(13, queue.memoryDeliveryCount());;      
         
         
      
  @@ -844,7 +849,7 @@
         
         for (int i = 12; i > 9; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //This should cause the down cache to be flushed
  @@ -864,13 +869,13 @@
         assertEquals(110, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 10 deliveries
  -      assertEquals(10, state.memoryDeliveryCount());;      
  +      assertEquals(10, queue.memoryDeliveryCount());;      
         
               
         
  @@ -878,7 +883,7 @@
         
         for (int i = 9; i >= 0; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         
  @@ -899,20 +904,20 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
         //Now there should be 120 message left to consume
         
         //Consume 50
         
  -      consumeInTx(queue, state, consumeCount, refs, 50);
  +      consumeInTx(queue, consumeCount, refs, 50);
         consumeCount += 50;
         
         //verify 0 ref in storage
  @@ -928,18 +933,18 @@
         assertEquals(70, ms.size());
         
         //Verify 70 refs in queue
  -      assertEquals(70, state.memoryRefCount());  
  +      assertEquals(70, queue.memoryRefCount());  
         
         //Verify not paging
  -      assertFalse(state.isPaging());      
  +      assertFalse(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
                     
         //Consume the rest
         
  -      consumeInTx(queue, state, consumeCount, refs, 70);
  +      consumeInTx(queue, consumeCount, refs, 70);
         consumeCount += 70;
         
         //verify 0 ref in storage
  @@ -955,13 +960,11 @@
         assertEquals(0, ms.size());
         
         //Verify 0 refs in queue
  -      assertEquals(0, state.memoryRefCount());
  -      
  -      //Make sure there are no more refs in state
  +      assertEquals(0, queue.memoryRefCount());
         
  -      MessageReference ref = state.removeFirstInMemory();
  +      //Make sure there are no more refs in queue
         
  -      assertNull(ref);
  +      assertEquals(0, queue.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
      }
  
  
  
  1.3       +139 -135  jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_2PCTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: SingleChannel_P_2PCTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_2PCTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- SingleChannel_P_2PCTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ SingleChannel_P_2PCTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,8 +23,7 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
   import org.jboss.messaging.core.SimpleDelivery;
  @@ -33,6 +32,8 @@
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   /**
    * 
    * A PagingTest_P_2PC_Recoverable.
  @@ -66,9 +67,7 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state = new ChannelState(queue, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
                          
         Message[] msgs = new Message[241];
         
  @@ -81,7 +80,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -105,16 +105,16 @@
         assertEquals(99, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         //Send one more ref
  @@ -122,7 +122,8 @@
         tx = createXATx();
         msgs[99] = MessageFactory.createCoreMessage(99, true, null);
         refs[99] = ms.reference(msgs[99]);
  -      state.addReference(refs[99], tx);
  +      queue.handle(null, refs[99], tx);
  +      refs[99].releaseMemoryReference();
         tx.prepare();
         tx.commit();
         
  @@ -145,16 +146,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
               
         //Verify paging
  -      assertTrue(state.isPaging());
  +      assertTrue(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         //Send 9 more
  @@ -164,7 +165,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);  
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -188,16 +190,16 @@
         assertEquals(109, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 9 refs in downcache
  -      assertEquals(9, state.downCacheCount());
  +      assertEquals(9, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -207,7 +209,8 @@
         tx = createXATx();
         msgs[109] = MessageFactory.createCoreMessage(109, true, null);
         refs[109] = ms.reference(msgs[109]);
  -      state.addReference(refs[109]);
  +      queue.handle(null, refs[109], null);
  +      refs[109].releaseMemoryReference();
         tx.prepare();
         tx.commit();
         
  @@ -231,16 +234,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -248,7 +251,8 @@
         tx = createXATx();
         msgs[110] = MessageFactory.createCoreMessage(110, true, null);
         refs[110] = ms.reference(msgs[110]);
  -      state.addReference(refs[110]);
  +      queue.handle(null, refs[110], null);
  +      refs[110].releaseMemoryReference();
         tx.prepare();
         tx.commit();
         
  @@ -272,16 +276,16 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -291,7 +295,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);   
  +         refs[i].releaseMemoryReference();
         }     
         tx.prepare();
         tx.commit();
  @@ -316,16 +321,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         //    Send 100 more refs then roll back
         tx = this.createXATx();
  @@ -333,7 +338,8 @@
         {
            Message m = MessageFactory.createCoreMessage(i, true, null);
            MessageReference ref = ms.reference(m);
  -         state.addReference(ref, tx);         
  +         queue.handle(null, ref, tx);       
  +         ref.releaseMemoryReference();
         }  
         tx.prepare();
         tx.rollback();
  @@ -345,7 +351,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);         
  +         refs[i].releaseMemoryReference();
         }  
         tx.prepare();
         tx.commit();
  @@ -370,16 +377,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -390,7 +397,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);      
  +         refs[i].releaseMemoryReference();
         }  
         tx.prepare();
         tx.commit();
  @@ -415,16 +423,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
   
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -433,7 +441,8 @@
         tx = createXATx();
         msgs[140] = MessageFactory.createCoreMessage(140, true, null);
         refs[140] = ms.reference(msgs[140]);
  -      state.addReference(refs[140]);
  +      queue.handle(null, refs[140], null);
  +      refs[140].releaseMemoryReference();
         tx.prepare();
         tx.commit();
         
  @@ -457,22 +466,22 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
                               
         //Consume 1
         int consumeCount = 0;
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 1);
  +      consumeIn2PCTx(queue, consumeCount, refs, 1);
         consumeCount++;
   
         //verify 40 unloaded refs in storage
  @@ -495,16 +504,16 @@
         assertEquals(100, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -513,7 +522,7 @@
         
         //Consume 18 more
        
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 18);
  +      consumeIn2PCTx(queue, consumeCount, refs, 18);
         consumeCount += 18;
         
         
  @@ -537,23 +546,23 @@
         assertEquals(82, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(81, state.memoryRefCount());
  +      assertEquals(81, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume one more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 1);
  +      consumeIn2PCTx(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //This should force a load of 20 and flush the downcache
  @@ -578,23 +587,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 20 more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 20);
  +      consumeIn2PCTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 1 unloaded ref in storage
  @@ -617,23 +626,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 1 more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 1);
  +      consumeIn2PCTx(queue, consumeCount, refs, 1);
         consumeCount ++;
         
         //verify 0 unloaded refs in storage
  @@ -655,23 +664,23 @@
         assertEquals(100, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume 20 more
         
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 20);
  +      consumeIn2PCTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 0 unloaded refs in storage
  @@ -693,23 +702,23 @@
         assertEquals(80, ms.size());
         
         //Verify 80 refs in queue
  -      assertEquals(80, state.memoryRefCount());
  +      assertEquals(80, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         //Consumer 60 more
         
               
  -      consumeIn2PCTx(queue, state, consumeCount, refs, 60);
  +      consumeIn2PCTx(queue, consumeCount, refs, 60);
         consumeCount += 60;
         
         //verify 0 unloaded refs in storage
  @@ -731,16 +740,16 @@
         assertEquals(20, ms.size());
         
         //Verify 20 refs in queue
  -      assertEquals(20, state.memoryRefCount());
  +      assertEquals(20, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -750,7 +759,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -772,16 +782,16 @@
         assertEquals(40, ms.size());
         
         //Verify 40 refs in queue
  -      assertEquals(40, state.memoryRefCount());
  +      assertEquals(40, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -792,7 +802,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -814,16 +825,16 @@
         assertEquals(60, ms.size());
         
         //Verify 60 refs in queue
  -      assertEquals(60, state.memoryRefCount());
  +      assertEquals(60, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -833,7 +844,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         tx.prepare();
         tx.commit();
  @@ -858,16 +870,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
          
  @@ -876,15 +888,8 @@
         //remove 20 but don't ack them yet
         //this should cause a load to be triggered
         
  -      SimpleDelivery[] dels = new SimpleDelivery[20];
  -      for (int i = 0; i < 20; i++)
  -      {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertEquals(refs[i + consumeCount].getMessageID(), ref.getMessageID());
  -         dels[i] = new SimpleDelivery(queue, ref, false);
  -         state.addDelivery(dels[i]);
  -      }
  +      SimpleDelivery[] dels = this.getDeliveries(queue, 20);
  +          
         
         //verify 0 ref in storage
         
  @@ -905,20 +910,20 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 20 deliveries
  -      assertEquals(20, state.memoryDeliveryCount());;      
  +      assertEquals(20, queue.memoryDeliveryCount());;      
         
         
          
         //Cancel last 7
         for (int i = 19; i > 12; i--)
         {
  -         state.cancelDelivery(dels[i]);   
  +         dels[i].cancel(); 
         }
         
         //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
  @@ -943,13 +948,13 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 13 deliveries
  -      assertEquals(13, state.memoryDeliveryCount());;      
  +      assertEquals(13, queue.memoryDeliveryCount());;      
         
         
      
  @@ -957,7 +962,7 @@
         
         for (int i = 12; i > 9; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //This should cause the down cache to be flushed
  @@ -982,13 +987,13 @@
         assertEquals(110, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 10 deliveries
  -      assertEquals(10, state.memoryDeliveryCount());;      
  +      assertEquals(10, queue.memoryDeliveryCount());;      
         
               
         
  @@ -996,7 +1001,7 @@
         
         for (int i = 9; i >= 0; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //consumeCount += 20;
  @@ -1023,13 +1028,13 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
   
  @@ -1038,7 +1043,7 @@
         
         //Consume 50
         
  -      consume(queue, state, consumeCount, refs, 50);
  +      consume(queue, consumeCount, refs, 50);
         consumeCount += 50;
         
         //verify 0 ref in storage
  @@ -1060,20 +1065,20 @@
         assertEquals(70, ms.size());
         
         //Verify 70 refs in queue
  -      assertEquals(70, state.memoryRefCount());  
  +      assertEquals(70, queue.memoryRefCount());  
         
         //Verify not paging
  -      assertFalse(state.isPaging());      
  +      assertFalse(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume the rest
         
  -      consume(queue, state, consumeCount, refs, 70);
  +      consume(queue, consumeCount, refs, 70);
         consumeCount += 70;
         
         //verify 0 ref in storage
  @@ -1092,13 +1097,12 @@
         assertEquals(0, ms.size());
         
         //Verify 0 refs in queue
  -      assertEquals(0, state.memoryRefCount());
  +      assertEquals(0, queue.memoryRefCount());
         
  -      //Make sure there are no more refs in state
  +      //Make sure there are no more refs in queue
         
  -      MessageReference ref = state.removeFirstInMemory();
  +      assertEquals(0, queue.messageCount());
         
  -      assertNull(ref);
         
         assertEquals(0, LockMap.instance.getSize());
            
  
  
  
  1.3       +137 -135  jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_NTTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: SingleChannel_P_NTTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_NTTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- SingleChannel_P_NTTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ SingleChannel_P_NTTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,8 +23,7 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
   import org.jboss.messaging.core.SimpleDelivery;
  @@ -32,6 +31,8 @@
   import org.jboss.messaging.core.message.MessageFactory;
   import org.jboss.messaging.core.plugin.LockMap;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   /**
    * 
    * A PagingTest_P_NT_Recoverable.
  @@ -65,9 +66,7 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state = new ChannelState(queue, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
                          
         Message[] msgs = new Message[241];
         
  @@ -79,7 +78,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         //verify no unloaded refs in storage
  @@ -101,23 +101,24 @@
         assertEquals(99, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         //Send one more ref
         
         msgs[99] = MessageFactory.createCoreMessage(99, true, null);
         refs[99] = ms.reference(msgs[99]);
  -      state.addReference(refs[99]);
  +      queue.handle(null, refs[99], null);
  +      refs[99].releaseMemoryReference();
         
         //verify no unloaded refs in storage
         
  @@ -138,16 +139,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
               
         //Verify paging
  -      assertTrue(state.isPaging());
  +      assertTrue(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         //Send 9 more
  @@ -156,7 +157,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);         
  +         refs[i].releaseMemoryReference();
         }
         
         //verify no unloaded refs in storage
  @@ -178,22 +180,23 @@
         assertEquals(109, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 9 refs in downcache
  -      assertEquals(9, state.downCacheCount());
  +      assertEquals(9, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         //Send one more ref - should clear the down cache
         
         msgs[109] = MessageFactory.createCoreMessage(109, true, null);
         refs[109] = ms.reference(msgs[109]);
  -      state.addReference(refs[109]);           
  +      queue.handle(null, refs[109], null);           
  +      refs[109].releaseMemoryReference();
         
         //verify 10 unloaded refs in storage
         
  @@ -215,16 +218,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -232,7 +235,8 @@
         
         msgs[110] = MessageFactory.createCoreMessage(110, true, null);
         refs[110] = ms.reference(msgs[110]);
  -      state.addReference(refs[110]);
  +      queue.handle(null, refs[110], null);
  +      refs[110].releaseMemoryReference();
         
         //verify 10 unloaded refs in storage
         
  @@ -254,16 +258,16 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -273,7 +277,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);        
  +         refs[i].releaseMemoryReference();
         }      
         
         //verify 20 unloaded refs in storage
  @@ -296,16 +301,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -316,7 +321,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);         
  +         refs[i].releaseMemoryReference();
         }  
         
         //verify 30 unloaded refs in storage
  @@ -339,16 +345,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -359,7 +365,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);         
  +         queue.handle(null, refs[i], null);         
  +         refs[i].releaseMemoryReference();
         }  
         
         //verify 40 unloaded refs in storage
  @@ -382,16 +389,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
   
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -400,7 +407,8 @@
         
         msgs[140] = MessageFactory.createCoreMessage(140, true, null);
         refs[140] = ms.reference(msgs[140]);
  -      state.addReference(refs[140]);
  +      queue.handle(null, refs[140], null);
  +      refs[140].releaseMemoryReference();
         
         //verify 40 unloaded refs in storage
         
  @@ -422,23 +430,23 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
                   
         
         
         //Consume 1
         int consumeCount = 0;
  -      consume(queue, state, consumeCount, refs, 1);
  +      consume(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //verify 40 unloaded refs in storage
  @@ -461,16 +469,16 @@
         assertEquals(100, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -478,7 +486,7 @@
         //Now we should have 99 refs in memory, 140 refs in storage, and 1 in down cache, 99 msgs in memory
         
         //Consume 18 more
  -      consume(queue, state, consumeCount, refs, 18);
  +      consume(queue, consumeCount, refs, 18);
         consumeCount += 18;
         
         
  @@ -502,23 +510,23 @@
         assertEquals(82, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(81, state.memoryRefCount());
  +      assertEquals(81, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume one more
         
  -      consume(queue, state, consumeCount, refs, 1);
  +      consume(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //This should force a load of 20 and flush the downcache
  @@ -543,23 +551,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 20 more
         
  -      consume(queue, state, consumeCount, refs, 20);
  +      consume(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 1 unloaded ref in storage
  @@ -582,23 +590,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 1 more
         
  -      consume(queue, state, consumeCount, refs, 1);
  +      consume(queue, consumeCount, refs, 1);
         consumeCount ++;
         
         //verify 0 unloaded refs in storage
  @@ -620,23 +628,23 @@
         assertEquals(100, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume 20 more
         
  -      consume(queue, state, consumeCount, refs, 20);
  +      consume(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 0 unloaded refs in storage
  @@ -658,22 +666,22 @@
         assertEquals(80, ms.size());
         
         //Verify 80 refs in queue
  -      assertEquals(80, state.memoryRefCount());
  +      assertEquals(80, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         //Consumer 60 more
                 
  -      consume(queue, state, consumeCount, refs, 60);
  +      consume(queue, consumeCount, refs, 60);
         consumeCount += 60;
         
         //verify 0 unloaded refs in storage
  @@ -695,16 +703,16 @@
         assertEquals(20, ms.size());
         
         //Verify 20 refs in queue
  -      assertEquals(20, state.memoryRefCount());
  +      assertEquals(20, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -713,7 +721,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         refIds = getUnloadedReferenceIds(queue.getChannelID());
  @@ -733,16 +742,16 @@
         assertEquals(40, ms.size());
         
         //Verify 40 refs in queue
  -      assertEquals(40, state.memoryRefCount());
  +      assertEquals(40, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -752,7 +761,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         refIds = getUnloadedReferenceIds(queue.getChannelID());
  @@ -772,16 +782,16 @@
         assertEquals(60, ms.size());
         
         //Verify 60 refs in queue
  -      assertEquals(60, state.memoryRefCount());
  +      assertEquals(60, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -790,7 +800,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i]);
  +         queue.handle(null, refs[i], null);
  +         refs[i].releaseMemoryReference();
         }
         
         //verify 20 unloaded ref in storage
  @@ -813,16 +824,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
          
  @@ -831,15 +842,8 @@
         //remove 20 but don't ack them yet
         //this should cause a load to be triggered
         
  -      SimpleDelivery[] dels = new SimpleDelivery[20];
  -      for (int i = 0; i < 20; i++)
  -      {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertEquals(refs[i + consumeCount].getMessageID(), ref.getMessageID());
  -         dels[i] = new SimpleDelivery(queue, ref, false);
  -         state.addDelivery(dels[i]);
  -      }
  +      SimpleDelivery[] dels = this.getDeliveries(queue, 20);
  +      
         
         //verify 0 ref in storage
         
  @@ -860,20 +864,20 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 20 deliveries
  -      assertEquals(20, state.memoryDeliveryCount());;      
  +      assertEquals(20, queue.memoryDeliveryCount());;      
         
         
          
         //Cancel last 7
         for (int i = 19; i > 12; i--)
         {
  -         state.cancelDelivery(dels[i]);   
  +         dels[i].cancel();
         }
         
         //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
  @@ -898,13 +902,13 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 13 deliveries
  -      assertEquals(13, state.memoryDeliveryCount());;      
  +      assertEquals(13, queue.memoryDeliveryCount());;      
         
         
      
  @@ -912,7 +916,7 @@
         
         for (int i = 12; i > 9; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //This should cause the down cache to be flushed
  @@ -937,13 +941,13 @@
         assertEquals(110, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 10 deliveries
  -      assertEquals(10, state.memoryDeliveryCount());;      
  +      assertEquals(10, queue.memoryDeliveryCount());;      
         
               
         
  @@ -951,7 +955,7 @@
         
         for (int i = 9; i >= 0; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //consumeCount += 20;
  @@ -978,13 +982,13 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
   
  @@ -993,7 +997,7 @@
         
         //Consume 50
         
  -      consume(queue, state, consumeCount, refs, 50);
  +      consume(queue, consumeCount, refs, 50);
         consumeCount += 50;
         
         //verify 0 ref in storage
  @@ -1015,20 +1019,20 @@
         assertEquals(70, ms.size());
         
         //Verify 70 refs in queue
  -      assertEquals(70, state.memoryRefCount());  
  +      assertEquals(70, queue.memoryRefCount());  
         
         //Verify not paging
  -      assertFalse(state.isPaging());      
  +      assertFalse(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume the rest
         
  -      consume(queue, state, consumeCount, refs, 70);
  +      consume(queue, consumeCount, refs, 70);
         consumeCount += 70;
         
         //verify 0 ref in storage
  @@ -1047,13 +1051,11 @@
         assertEquals(0, ms.size());
         
         //Verify 0 refs in queue
  -      assertEquals(0, state.memoryRefCount());
  -      
  -      //Make sure there are no more refs in state
  +      assertEquals(0, queue.memoryRefCount());
         
  -      MessageReference ref = state.removeFirstInMemory();
  +      //Make sure there are no more refs in queue
         
  -      assertNull(ref);
  +      assertEquals(0, queue.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
         
  
  
  
  1.3       +139 -135  jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_TTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: SingleChannel_P_TTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_TTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- SingleChannel_P_TTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ SingleChannel_P_TTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,8 +23,7 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
   import org.jboss.messaging.core.SimpleDelivery;
  @@ -33,6 +32,8 @@
   import org.jboss.messaging.core.plugin.LockMap;
   import org.jboss.messaging.core.tx.Transaction;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   /**
    * 
    * A PagingTest_P_T_Recoverable.
  @@ -66,9 +67,7 @@
      
      public void test1() throws Throwable
      {
  -      Channel queue = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state = new ChannelState(queue, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
                          
         Message[] msgs = new Message[241];
         
  @@ -81,7 +80,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -104,16 +104,16 @@
         assertEquals(99, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         //Send one more ref
  @@ -121,7 +121,8 @@
         tx = tr.createTransaction();
         msgs[99] = MessageFactory.createCoreMessage(99, true, null);
         refs[99] = ms.reference(msgs[99]);
  -      state.addReference(refs[99], tx);
  +      queue.handle(null, refs[99], tx);
  +      refs[99].releaseMemoryReference();
         tx.commit();
         
         //verify no unloaded refs in storage
  @@ -143,16 +144,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
               
         //Verify paging
  -      assertTrue(state.isPaging());
  +      assertTrue(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         //Send 9 more
  @@ -162,7 +163,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);         
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -185,16 +187,16 @@
         assertEquals(109, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 9 refs in downcache
  -      assertEquals(9, state.downCacheCount());
  +      assertEquals(9, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -204,7 +206,8 @@
         tx = tr.createTransaction();
         msgs[109] = MessageFactory.createCoreMessage(109, true, null);
         refs[109] = ms.reference(msgs[109]);
  -      state.addReference(refs[109], tx);
  +      queue.handle(null, refs[109], tx);
  +      refs[109].releaseMemoryReference();
         tx.commit();
         
         //verify 10 unloaded refs in storage
  @@ -227,16 +230,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -244,7 +247,8 @@
         tx = tr.createTransaction();
         msgs[110] = MessageFactory.createCoreMessage(110, true, null);
         refs[110] = ms.reference(msgs[110]);
  -      state.addReference(refs[110], tx);
  +      queue.handle(null, refs[110], tx);
  +      refs[110].releaseMemoryReference();
         tx.commit();
         
         //verify 10 unloaded refs in storage
  @@ -267,16 +271,16 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -286,7 +290,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);         
  +         refs[i].releaseMemoryReference();
         }      
         tx.commit();
         
  @@ -310,16 +315,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -330,7 +335,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx);         
  +         refs[i].releaseMemoryReference();
         }  
         tx.commit();
         
  @@ -354,16 +360,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         //Send 100 more refs then roll back
         tx = tr.createTransaction();
  @@ -371,7 +377,8 @@
         {
            Message m = MessageFactory.createCoreMessage(i, true, null);
            MessageReference ref = ms.reference(m);
  -         state.addReference(ref, tx);         
  +         queue.handle(null, ref, tx);         
  +         ref.releaseMemoryReference();
         }  
         tx.rollback();
         
  @@ -382,7 +389,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);         
  +         queue.handle(null, refs[i], tx); 
  +         refs[i].releaseMemoryReference();
         }  
         tx.commit();
         
  @@ -406,16 +414,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
   
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -424,7 +432,8 @@
         tx = tr.createTransaction();
         msgs[140] = MessageFactory.createCoreMessage(140, true, null);
         refs[140] = ms.reference(msgs[140]);
  -      state.addReference(refs[140], tx);
  +      queue.handle(null, refs[140], tx);
  +      refs[140].releaseMemoryReference();
         tx.commit();
         
         //verify 40 unloaded refs in storage
  @@ -447,22 +456,22 @@
         assertEquals(101, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());  
  +      assertTrue(queue.isPaging());  
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
                               
         //Consume 1
         int consumeCount = 0;
         
  -      consumeInTx(queue, state, consumeCount, refs, 1);
  +      consumeInTx(queue, consumeCount, refs, 1);
         consumeCount++;
   
         //verify 40 unloaded refs in storage
  @@ -485,16 +494,16 @@
         assertEquals(100, ms.size());
         
         //Verify 99 refs in queue
  -      assertEquals(99, state.memoryRefCount());
  +      assertEquals(99, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -503,7 +512,7 @@
         
         //Consume 18 more
        
  -      consumeInTx(queue, state, consumeCount, refs, 18);
  +      consumeInTx(queue, consumeCount, refs, 18);
         consumeCount += 18;
         
         
  @@ -527,23 +536,23 @@
         assertEquals(82, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(81, state.memoryRefCount());
  +      assertEquals(81, queue.memoryRefCount());
         
         //Verify 1 refs in downcache
  -      assertEquals(1, state.downCacheCount());
  +      assertEquals(1, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume one more
         
  -      consumeInTx(queue, state, consumeCount, refs, 1);
  +      consumeInTx(queue, consumeCount, refs, 1);
         consumeCount++;
         
         //This should force a load of 20 and flush the downcache
  @@ -568,23 +577,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 20 more
         
  -      consumeInTx(queue, state, consumeCount, refs, 20);
  +      consumeInTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 1 unloaded ref in storage
  @@ -607,23 +616,23 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
         
         //Consume 1 more
         
  -      consumeInTx(queue, state, consumeCount, refs, 1);
  +      consumeInTx(queue, consumeCount, refs, 1);
         consumeCount ++;
         
         //verify 0 unloaded refs in storage
  @@ -645,23 +654,23 @@
         assertEquals(100, ms.size());
         
         //Verify 81 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume 20 more
         
  -      consumeInTx(queue, state, consumeCount, refs, 20);
  +      consumeInTx(queue, consumeCount, refs, 20);
         consumeCount += 20;
         
         //verify 0 unloaded refs in storage
  @@ -683,23 +692,23 @@
         assertEquals(80, ms.size());
         
         //Verify 80 refs in queue
  -      assertEquals(80, state.memoryRefCount());
  +      assertEquals(80, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         //Consumer 60 more
         
               
  -      consumeInTx(queue, state, consumeCount, refs, 60);
  +      consumeInTx(queue, consumeCount, refs, 60);
         consumeCount += 60;
         
         //verify 0 unloaded refs in storage
  @@ -721,16 +730,16 @@
         assertEquals(20, ms.size());
         
         //Verify 20 refs in queue
  -      assertEquals(20, state.memoryRefCount());
  +      assertEquals(20, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
               
         
         
  @@ -740,7 +749,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -761,16 +771,16 @@
         assertEquals(40, ms.size());
         
         //Verify 40 refs in queue
  -      assertEquals(40, state.memoryRefCount());
  +      assertEquals(40, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -781,7 +791,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -802,16 +813,16 @@
         assertEquals(60, ms.size());
         
         //Verify 60 refs in queue
  -      assertEquals(60, state.memoryRefCount());
  +      assertEquals(60, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify not paging
  -      assertFalse(state.isPaging());
  +      assertFalse(queue.isPaging());
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
  @@ -821,7 +832,8 @@
         {
            msgs[i] = MessageFactory.createCoreMessage(i, true, null);
            refs[i] = ms.reference(msgs[i]);
  -         state.addReference(refs[i], tx);
  +         queue.handle(null, refs[i], tx);
  +         refs[i].releaseMemoryReference();
         }
         tx.commit();
         
  @@ -845,16 +857,16 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify 0 refs in downcache
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify no deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
          
  @@ -863,15 +875,8 @@
         //remove 20 but don't ack them yet
         //this should cause a load to be triggered
         
  -      SimpleDelivery[] dels = new SimpleDelivery[20];
  -      for (int i = 0; i < 20; i++)
  -      {
  -         MessageReference ref = state.removeFirstInMemory();
  -         assertNotNull(ref);
  -         assertEquals(refs[i + consumeCount].getMessageID(), ref.getMessageID());
  -         dels[i] = new SimpleDelivery(queue, ref, false);
  -         state.addDelivery(dels[i]);
  -      }
  +      SimpleDelivery[] dels = this.getDeliveries(queue, 20);
  +      
         
         //verify 0 ref in storage
         
  @@ -892,20 +897,20 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 20 deliveries
  -      assertEquals(20, state.memoryDeliveryCount());;      
  +      assertEquals(20, queue.memoryDeliveryCount());;      
         
         
          
         //Cancel last 7
         for (int i = 19; i > 12; i--)
         {
  -         state.cancelDelivery(dels[i]);   
  +         dels[i].cancel();   
         }
         
         //This should cause the refs corresponding to the deliveries to go the front of the in memory quuee
  @@ -930,13 +935,13 @@
         assertEquals(120, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 13 deliveries
  -      assertEquals(13, state.memoryDeliveryCount());;      
  +      assertEquals(13, queue.memoryDeliveryCount());;      
         
         
      
  @@ -944,7 +949,7 @@
         
         for (int i = 12; i > 9; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //This should cause the down cache to be flushed
  @@ -969,13 +974,13 @@
         assertEquals(110, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 10 deliveries
  -      assertEquals(10, state.memoryDeliveryCount());;      
  +      assertEquals(10, queue.memoryDeliveryCount());;      
         
               
         
  @@ -983,7 +988,7 @@
         
         for (int i = 9; i >= 0; i--)
         {
  -         state.cancelDelivery(dels[i]);
  +         dels[i].cancel();
         }
         
         //consumeCount += 20;
  @@ -1010,13 +1015,13 @@
         assertEquals(100, ms.size());
         
         //Verify 100 refs in queue
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
         //Verify paging
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());;      
  +      assertEquals(0, queue.memoryDeliveryCount());;      
         
         
   
  @@ -1025,7 +1030,7 @@
         
         //Consume 50
         
  -      consumeInTx(queue, state, consumeCount, refs, 50);
  +      consumeInTx(queue, consumeCount, refs, 50);
         consumeCount += 50;
         
         //verify 0 ref in storage
  @@ -1047,20 +1052,20 @@
         assertEquals(70, ms.size());
         
         //Verify 70 refs in queue
  -      assertEquals(70, state.memoryRefCount());  
  +      assertEquals(70, queue.memoryRefCount());  
         
         //Verify not paging
  -      assertFalse(state.isPaging());      
  +      assertFalse(queue.isPaging());      
         
         //Verify 0 deliveries
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         
         
         
         //Consume the rest
         
  -      consumeInTx(queue, state, consumeCount, refs, 70);
  +      consumeInTx(queue, consumeCount, refs, 70);
         consumeCount += 70;
         
         //verify 0 ref in storage
  @@ -1079,13 +1084,12 @@
         assertEquals(0, ms.size());
         
         //Verify 0 refs in queue
  -      assertEquals(0, state.memoryRefCount());
  +      assertEquals(0, queue.memoryRefCount());
         
  -      //Make sure there are no more refs in state
  +      //Make sure there are no more refs in queue
         
  -      MessageReference ref = state.removeFirstInMemory();
  +      assertEquals(0, queue.messageCount());
         
  -      assertNull(ref);
         
         assertEquals(0, LockMap.instance.getSize());
            
  
  
  
  1.3       +23 -24    jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_ReloadTest.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: SingleChannel_ReloadTest.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-jms/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_ReloadTest.java,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -b -r1.2 -r1.3
  --- SingleChannel_ReloadTest.java	27 Jun 2006 19:44:41 -0000	1.2
  +++ SingleChannel_ReloadTest.java	17 Jul 2006 17:14:51 -0000	1.3
  @@ -23,8 +23,7 @@
   
   import java.util.List;
   
  -import org.jboss.messaging.core.Channel;
  -import org.jboss.messaging.core.ChannelState;
  +import org.jboss.messaging.core.ChannelSupport;
   import org.jboss.messaging.core.Message;
   import org.jboss.messaging.core.MessageReference;
   import org.jboss.messaging.core.local.Queue;
  @@ -34,6 +33,8 @@
   import org.jboss.messaging.core.plugin.SimpleMessageStore;
   import org.jboss.messaging.core.tx.TransactionRepository;
   
  +import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
  +
   /**
    * 
    * A PagingTest_Reload.
  @@ -65,9 +66,7 @@
      
      public void testReload() throws Throwable
      {
  -      Channel queue = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state = new ChannelState(queue, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
           
         Message[] msgs = new Message[200];
         
  @@ -80,7 +79,9 @@
            
            refs[i] = ms.reference(msgs[i]);
                   
  -         state.addReference(refs[i]); 
  +         queue.handle(null, refs[i], null); 
  +         
  +         refs[i].releaseMemoryReference();
         }
         
         //Send 50 p messages
  @@ -90,19 +91,21 @@
            
            refs[i] = ms.reference(msgs[i]);
                   
  -         state.addReference(refs[i]); 
  +         queue.handle(null, refs[i], null); 
  +         
  +         refs[i].releaseMemoryReference();
         }
   
         List refIds = getReferenceIds(queue.getChannelID());
         assertEquals(100, refIds.size());
                                                   
  -      assertEquals(100, state.memoryRefCount());
  +      assertEquals(100, queue.memoryRefCount());
         
  -      assertEquals(0, state.downCacheCount());
  +      assertEquals(0, queue.downCacheCount());
         
  -      assertTrue(state.isPaging());      
  +      assertTrue(queue.isPaging());      
         
  -      assertEquals(0, state.memoryDeliveryCount());
  +      assertEquals(0, queue.memoryDeliveryCount());
         
         //Stop and restart the persistence manager
         //Only the persistent messages should survive
  @@ -122,31 +125,27 @@
         
         tr.start(pm);
            
  -      Channel queue2 = new Queue(1, ms, pm, null, true, 100, 20, 10);
  -      
  -      ChannelState state2 = new ChannelState(queue2, pm, null, true, true, 100, 20, 10);
  +      ChannelSupport queue2 = new Queue(1, ms, pm, null, true, 100, 20, 10, new QueuedExecutor());
         
  -      state2.load();
  +      queue2.load();
         
         refIds = getReferenceIds(queue.getChannelID());
         assertEquals(50, refIds.size());
                     
  -      this.consume(queue2, state2, 150, refs, 50);
  +      this.consume(queue2, 150, refs, 50);
         
         refIds = getReferenceIds(queue2.getChannelID());
         assertEquals(0, refIds.size());
                                                   
  -      assertEquals(0, state2.memoryRefCount());
  -      
  -      assertEquals(0, state2.downCacheCount());
  +      assertEquals(0, queue2.memoryRefCount());
         
  -      assertFalse(state2.isPaging());      
  +      assertEquals(0, queue2.downCacheCount());
         
  -      assertEquals(0, state2.memoryDeliveryCount());
  +      assertFalse(queue2.isPaging());      
         
  -      MessageReference ref = state2.removeFirstInMemory();
  +      assertEquals(0, queue2.memoryDeliveryCount());
         
  -      assertNull(ref);
  +      assertEquals(0, queue2.messageCount());
         
         assertEquals(0, LockMap.instance.getSize());
      }
  
  
  



More information about the jboss-cvs-commits mailing list