[jboss-cvs] JBoss Messaging SVN: r1371 - in trunk/tests/src/org/jboss/test/messaging: core/local core/local/base core/paging core/paging/base jms/stress jms/stress/base
jboss-cvs-commits at lists.jboss.org
jboss-cvs-commits at lists.jboss.org
Wed Sep 27 22:09:12 EDT 2006
Author: ovidiu.feodorov at jboss.com
Date: 2006-09-27 22:09:05 -0400 (Wed, 27 Sep 2006)
New Revision: 1371
Added:
trunk/tests/src/org/jboss/test/messaging/core/local/base/PagingFilteredQueueTestBase.java
trunk/tests/src/org/jboss/test/messaging/core/paging/base/
trunk/tests/src/org/jboss/test/messaging/core/paging/base/PagingStateTestBase.java
trunk/tests/src/org/jboss/test/messaging/jms/stress/base/
trunk/tests/src/org/jboss/test/messaging/jms/stress/base/StressTestBase.java
Removed:
trunk/tests/src/org/jboss/test/messaging/core/local/PagingFilteredQueueTestBase.java
trunk/tests/src/org/jboss/test/messaging/core/paging/PagingStateTestBase.java
trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTestBase.java
Modified:
trunk/tests/src/org/jboss/test/messaging/core/local/NonRecoverablePagingFilteredQueueTest.java
trunk/tests/src/org/jboss/test/messaging/core/local/RecoverablePagingFilteredQueueTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_2PCTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_NTTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_TTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_2PCTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_NTTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_TTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_2PCTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_NTTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_TTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_2PCTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_NTTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_TTest.java
trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_ReloadTest.java
trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTest.java
Log:
minor refactoring: moving Base classes in corresponding 'base' directories
Modified: trunk/tests/src/org/jboss/test/messaging/core/local/NonRecoverablePagingFilteredQueueTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/local/NonRecoverablePagingFilteredQueueTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/local/NonRecoverablePagingFilteredQueueTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -22,6 +22,7 @@
package org.jboss.test.messaging.core.local;
import org.jboss.messaging.core.local.PagingFilteredQueue;
+import org.jboss.test.messaging.core.local.base.PagingFilteredQueueTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Deleted: trunk/tests/src/org/jboss/test/messaging/core/local/PagingFilteredQueueTestBase.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/local/PagingFilteredQueueTestBase.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/local/PagingFilteredQueueTestBase.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -1,6427 +0,0 @@
-/*
-* JBoss, Home of Professional Open Source
-* Copyright 2005, JBoss Inc., and individual contributors as indicated
-* by the @authors tag. See the copyright.txt in the distribution for a
-* full listing of individual contributors.
-*
-* This is free software; you can redistribute it and/or modify it
-* under the terms of the GNU Lesser General Public License as
-* published by the Free Software Foundation; either version 2.1 of
-* the License, or (at your option) any later version.
-*
-* This software is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-* Lesser General Public License for more details.
-*
-* You should have received a copy of the GNU Lesser General Public
-* License along with this software; if not, write to the Free
-* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
-*/
-package org.jboss.test.messaging.core.local;
-
-import java.io.Serializable;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import org.jboss.messaging.core.Delivery;
-import org.jboss.messaging.core.Filter;
-import org.jboss.messaging.core.Message;
-import org.jboss.messaging.core.MessageReference;
-import org.jboss.messaging.core.Receiver;
-import org.jboss.messaging.core.local.PagingFilteredQueue;
-import org.jboss.messaging.core.message.CoreMessage;
-import org.jboss.messaging.core.plugin.IdManager;
-import org.jboss.messaging.core.plugin.JDBCPersistenceManager;
-import org.jboss.messaging.core.plugin.SimpleMessageStore;
-import org.jboss.messaging.core.plugin.contract.MessageStore;
-import org.jboss.messaging.core.plugin.contract.PersistenceManager;
-import org.jboss.messaging.core.tx.Transaction;
-import org.jboss.messaging.core.tx.TransactionRepository;
-import org.jboss.test.messaging.MessagingTestCase;
-import org.jboss.test.messaging.core.BrokenReceiver;
-import org.jboss.test.messaging.core.SimpleDeliveryObserver;
-import org.jboss.test.messaging.core.SimpleFilter;
-import org.jboss.test.messaging.core.SimpleReceiver;
-import org.jboss.test.messaging.tools.jmx.ServiceContainer;
-import org.jboss.test.messaging.util.CoreMessageFactory;
-
-import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
-
-/**
- * The QueueTest test strategy is to try as many combination as it makes sense of the following
- * variables:
- *
- * 1. The Queue can be non-recoverable or
- * recoverable. A non-recoverable channel can accept reliable messages or not.
- * 2. The Queue may have zero or one receivers (the behavior for more than one receiver depends
- * on the particular router implementation).
- * 3. The receiver may be ACKING or NACKING (the case when it throws unchecked exceptions is handled
- * at the Router level).
- * 4. The sender can send message(s) non-transactionally or transactionally (and then can commit
- * or rollback the transaction).
- * 5. The NACKING receiver can send acknowledgment(s) non-transactionally or transactionally (and
- * then can commit or rollback the transaction).
- * 6. The message can be non-reliable or reliable.
- * 7. The sender can send one or multiple messages.
- * 8. A recoverable channel may be crashed and tested if it successfully recovers.
- *
- * This test base also tests the Distributor interface.
- *
- * @author <a href="mailto:ovidiu at jboss.org">Ovidiu Feodorov</a>
- * @author <a href="mailto:tim.fox at jboss.com">Tim Fox</a>
- * @version <tt>$Revision: 1019 $</tt>
- *
- * $Id: ChannelTestBase.java 1019 2006-07-17 17:15:04Z timfox $
- */
-public abstract class PagingFilteredQueueTestBase extends MessagingTestCase
-{
- // Constants -----------------------------------------------------
-
- public static final int NUMBER_OF_MESSAGES = 10;
-
- // Static --------------------------------------------------------
-
- // Attributes ----------------------------------------------------
-
- protected PersistenceManager pm;
-
- protected TransactionRepository tr;
-
- protected MessageStore ms;
-
- protected ServiceContainer sc;
-
- protected PagingFilteredQueue queue;
-
- // Constructors --------------------------------------------------
-
- public PagingFilteredQueueTestBase(String name)
- {
- super(name);
- }
-
- // Public --------------------------------------------------------
-
- public void setUp() throws Exception
- {
- super.setUp();
-
- sc = new ServiceContainer("all,-remoting,-security");
- sc.start();
-
- pm =
- new JDBCPersistenceManager(sc.getDataSource(), sc.getTransactionManager(), null,
- true, true, true, 100);
- pm.start();
-
- tr = new TransactionRepository(pm, new IdManager("TRANSACTION_ID", 10, pm));
- tr.start();
-
- ms = new SimpleMessageStore();
- ms.start();
- }
-
- public void tearDown() throws Exception
- {
- sc.stop();
- sc = null;
-
- ms = null;
- tr = null;
- super.tearDown();
- }
-
- public static void assertEqualSets(MessageReference[] a, List msgs)
- {
- assertEquals(a.length, msgs.size());
- List l = new ArrayList(msgs);
-
- for(int i = 0; i < a.length; i++)
- {
- for(Iterator j = l.iterator(); j.hasNext(); )
- {
- Object o = j.next();
- Message m = (Message)o;
-
-
- if (a[i].getMessageID() == m.getMessageID() &&
- m.getPayload().equals(a[i].getMessage().getPayload()))
- {
- j.remove();
- break;
- }
- }
- }
-
- if (!l.isEmpty())
- {
- fail("Messages " + l + " do not match!");
- }
- }
-
- public static void assertEqualSets(Delivery[] a, List deliveries)
- {
- assertEquals(a.length, deliveries.size());
- List l = new ArrayList(deliveries);
-
- for(int i = 0; i < a.length; i++)
- {
- for(Iterator j = l.iterator(); j.hasNext(); )
- {
- Delivery d = (Delivery)j.next();
- MessageReference ref = d.getReference();
-
- if (a[i].getReference().getMessageID() == ref.getMessageID())
- {
- j.remove();
- break;
- }
- }
- }
-
- if (!l.isEmpty())
- {
- fail("Deliveries " + l + " do not match!");
- }
- }
-
-
- // Channel tests -------------------------------------------------
-
-
- public void testWithFilter()
- {
- Filter f = new SimpleFilter(3);
-
- PagingFilteredQueue queue = new PagingFilteredQueue("queue1", 1, ms, pm, true, false, new QueuedExecutor(), f);
-
- Message m1 = new CoreMessage(1, false, 0, 0, (byte)0, null, null, 0);
- Message m2 = new CoreMessage(2, false, 0, 0, (byte)0, null, null, 0);
- Message m3 = new CoreMessage(3, false, 0, 0, (byte)0, null, null, 0);
- Message m4 = new CoreMessage(4, false, 0, 0, (byte)0, null, null, 0);
- Message m5 = new CoreMessage(5, false, 0, 0, (byte)0, null, null, 0);
-
- MessageReference ref1 = ms.reference(m1);
- MessageReference ref2 = ms.reference(m2);
- MessageReference ref3 = ms.reference(m3);
- MessageReference ref4 = ms.reference(m4);
- MessageReference ref5 = ms.reference(m5);
-
- Delivery del = queue.handle(null, ref1, null);
- assertFalse(del.isSelectorAccepted());
-
- del = queue.handle(null, ref2, null);
- assertFalse(del.isSelectorAccepted());
-
- del = queue.handle(null, ref3, null);
- assertTrue(del.isSelectorAccepted());
-
- del = queue.handle(null, ref4, null);
- assertFalse(del.isSelectorAccepted());
-
- del = queue.handle(null, ref5, null);
- assertFalse(del.isSelectorAccepted());
- }
-
-
- public void testUnreliableSynchronousDeliveryTwoReceivers() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
- SimpleReceiver r1 = new SimpleReceiver("ONE", SimpleReceiver.ACKING);
- SimpleReceiver r2 = new SimpleReceiver("TWO", SimpleReceiver.ACKING);
-
- queue.add(r1);
- queue.add(r2);
-
- Delivery d = queue.handle(observer, createReference(0, false, "payload"), null);
-
- assertTrue(d.isDone());
- List l1 = r1.getMessages();
- List l2 = r2.getMessages();
- if (l2.isEmpty())
- {
- assertEquals(1, l1.size());
- Message m = (Message)l1.get(0);
- assertEquals("payload", m.getPayload());
- }
- else
- {
- assertTrue(l1.isEmpty());
- assertEquals(1, l2.size());
- Message m = (Message)l2.get(0);
- assertEquals("payload", m.getPayload());
- }
- }
-
-
- public void testReliableSynchronousDeliveryTwoReceivers() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
- SimpleReceiver r1 = new SimpleReceiver("ONE", SimpleReceiver.ACKING);
- SimpleReceiver r2 = new SimpleReceiver("TWO", SimpleReceiver.ACKING);
- assertTrue(queue.add(r1));
- assertTrue(queue.add(r2));
-
- Delivery d = queue.handle(observer, createReference(0, true, "payload"), null);
-
- assertTrue(d.isDone());
- List l1 = r1.getMessages();
- List l2 = r2.getMessages();
- if (l2.isEmpty())
- {
- assertEquals(1, l1.size());
- Message m = (Message)l1.get(0);
- assertEquals("payload", m.getPayload());
- }
- else
- {
- assertTrue(l1.isEmpty());
- assertEquals(1, l2.size());
- Message m = (Message)l2.get(0);
- assertEquals("payload", m.getPayload());
- }
- }
-
- /*
- * If a channel has a set a receiver and remove is called with a different receiver
- * need to ensure the receiver is not removed (since it doesn't match)
- */
- public void testRemoveDifferentReceiver() throws Exception
- {
- Receiver receiver1 = new SimpleReceiver();
-
- Receiver receiver2 = new SimpleReceiver();
-
- assertFalse(queue.iterator().hasNext());
-
- queue.add(receiver1);
-
- assertTrue(queue.contains(receiver1));
-
- queue.remove(receiver1);
-
- assertFalse(queue.iterator().hasNext());
-
- assertFalse(queue.contains(receiver1));
-
- queue.add(receiver1);
-
- assertTrue(queue.contains(receiver1));
-
- queue.remove(receiver2);
-
- assertTrue(queue.contains(receiver1));
-
- }
-
- public void testClosedChannel() throws Exception
- {
- queue.close();
- try
- {
- queue.handle(null, createReference(0), null);
- fail("should throw exception");
- }
- catch(IllegalStateException e)
- {
- //OK
- }
- }
-
- public void testHandleNullRoutable() throws Exception
- {
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
- assertNull(queue.handle(observer, null, null));
- }
-
- //////////////////////////////////
- ////////////////////////////////// Test matrix
- //////////////////////////////////
-
- //
- // Non-recoverable channel
- //
-
- ////
- //// Zero receivers
- ////
-
- //////
- ////// Non-transacted send
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
- queue.add(receiver);
- queue.deliver(true);
- assertEquals(1, receiver.getMessages().size());
- assertEquals(0, ((Message)receiver.getMessages().get(0)).getMessageID());
-
- queue.deliver(true);
- assertEquals(1, receiver.getMessages().size());
-
-
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- List stored = queue.browse();
- assertEqualSets(refs, stored);
-
- SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
- queue.add(receiver);
- queue.deliver(true);
- assertEquals(10, receiver.getMessages().size());
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- assertEquals(i, ((Message)receiver.getMessages().get(i)).getMessageID());
- }
- receiver.clear();
-
- queue.deliver(true);
- assertEquals(0, receiver.getMessages().size());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_3_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- // the channel must not accept the message
- assertNull(delivery);
-
- assertTrue(queue.browse().isEmpty());
-
- queue.deliver(true);
-
- Receiver r = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
-
- queue.add(r);
-
- queue.deliver(true);
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_3_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- queue.deliver(true);
-
- SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
- queue.add(receiver);
- queue.deliver(true);
- assertEquals(1, receiver.getMessages().size());
- assertEquals(0, ((Message)receiver.getMessages().get(0)).getMessageID());
-
- queue.deliver(true);
- assertEquals(1, receiver.getMessages().size());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_4_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- // the channel must not accept the message
- assertNull(delivery);
-
- queue.deliver(true);
-
- Receiver r = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
-
- queue.add(r);
-
- queue.deliver(true);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_4_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
-
- SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
- queue.add(receiver);
- queue.deliver(true);
- assertEquals(10, receiver.getMessages().size());
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- assertEquals(i, ((Message)receiver.getMessages().get(i)).getMessageID());
- }
- receiver.clear();
-
- queue.deliver(true);
- assertEquals(0, receiver.getMessages().size());
- }
-
-
-
- //////
- ////// Transacted send and commit
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_5() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
-
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_6() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- List stored = queue.browse();
- assertEqualSets(refs, stored);
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_7_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_7_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_8_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
-
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_8_1_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
-
- }
-
- public void testNonRecoverableChannel_8_1_mixed_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES * 2];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i + NUMBER_OF_MESSAGES] = createReference(i + NUMBER_OF_MESSAGES , true, "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i + NUMBER_OF_MESSAGES], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
-
- }
-
-
- public void testNonRecoverableChannel_8_1_mixed_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES * 2];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i + NUMBER_OF_MESSAGES] = createReference(i + NUMBER_OF_MESSAGES , true, "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i + NUMBER_OF_MESSAGES], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
-
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_8_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_8_2_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- }
-
-
- //////
- ////// Transacted send and rollback
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_9() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_10() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_11() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_12() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_12_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- ////
- //// One receiver
- ////
-
- //////
- ////// ACKING receiver
- //////
-
- //////
- ////// Non-transacted send
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_13() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_14() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEqualSets(refs, received);
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_15_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertNull(delivery);
-
- assertTrue(queue.browse().isEmpty());
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_15_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_16_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertNull(delivery);
- }
-
- assertTrue(queue.browse().isEmpty());
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_16_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertTrue(queue.browse().isEmpty());
- assertEqualSets(refs, r.getMessages());
- }
-
- //////
- ////// Transacted send and commit
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_17() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_18() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- assertEqualSets(refs, r.getMessages());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_19_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_19_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_20_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_20_1_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_20_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- assertEqualSets(refs, r.getMessages());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_20_2_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- assertEqualSets(refs, r.getMessages());
- }
-
- //////
- ////// Transacted send and rollback
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_21() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_22() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_23() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_24() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_24_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- //////
- ////// NACKING receiver
- //////
-
- //////
- ////// Non-transacted send
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- public void testNonRecoverableChannel_25() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
- /**
- * The same test as before, but with a Receiver configured to acknowledge immediately
- * on the Delivery. Simulates a race condition in which the acknoledgment arrives before
- * the Delivery is returned to channel.
- *
- * @throws Throwable
- */
- public void testNonRecoverableChannel_25_race() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- r.setImmediateAsynchronousAcknowledgment(true);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- // the receiver should have returned a "done" delivery
- assertTrue(queue.browse().isEmpty());
-
- List messages = r.getMessages();
- assertEquals(1, messages.size());
- Message ackm = (Message)messages.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // an extra acknowledgment should be discarded
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and commit
- ////////////
-
- public void testNonRecoverableChannel_25_1() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- Transaction tx = tr.createTransaction();
-
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and rollback
- ////////////
-
- public void testNonRecoverableChannel_25_2() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- Transaction tx = tr.createTransaction();
-
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- tx.rollback();
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- // acknowledge non-transactionally
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- //////////
- ////////// Multiple message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- public void testNonRecoverableChannel_26() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
-
- }
-
- ////////////
- //////////// Transacted acknowledgment and commit
- ////////////
-
- public void testNonRecoverableChannel_26_1() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- Transaction tx = tr.createTransaction();
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
- }
-
- assertEqualSets(refs, queue.browse());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and rollback
- ////////////
-
- public void testNonRecoverableChannel_26_2() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- Transaction tx = tr.createTransaction();
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
- }
-
- assertEqualSets(refs, queue.browse());
-
- tx.rollback();
-
- assertEqualSets(refs, queue.browse());
-
- // acknowledge non-transactionally
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_27_1_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- // not accepted by the channel
- assertNull(delivery);
- assertTrue(queue.browse().isEmpty());
- assertTrue(r.getMessages().isEmpty());
-
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_27_1_2() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message rm = (Message)received.iterator().next();
- assertTrue(rm.isReliable());
- assertEquals(0, rm.getMessageID());
-
- r.acknowledge(rm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment
- ////////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
-
- // Doesn't make sense, the message won't be accepted anyway.
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
-
- public void testNonRecoverableChannel_27_2_2() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message rm = (Message)received.iterator().next();
- assertTrue(rm.isReliable());
- assertEquals(0, rm.getMessageID());
-
- Transaction tx = tr.createTransaction();
-
- r.acknowledge(rm, tx);
-
- stored = queue.browse();
- assertEquals(1, stored.size());
- sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_28_1_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- // not accepted by the channel
- assertNull(delivery);
- }
-
- assertTrue(queue.browse().isEmpty());
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_28_1_2() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment
- ////////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- // Doesn't make sense, the message won't be accepted anyway.
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_28_2_2() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- Transaction tx = tr.createTransaction();
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- r.acknowledge(ackm, tx);
- }
-
- assertEqualSets(refs, queue.browse());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
- //////
- ////// Transacted send and commit
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_29() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_30() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_31_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////
- /////////// Channel does accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_31_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message rm = (Message)received.iterator().next();
- assertTrue(rm.isReliable());
- assertEquals(0, rm.getMessageID());
- }
-
-
- //////////
- ////////// Multiple message
- //////////
-
- ///////////
- /////////// Channel does NOT accept reliable messages
- ///////////
-
- public void testNonRecoverableChannel_32_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_32_1_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (queue.acceptReliableMessages())
- {
- // we test channels that don't accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- try
- {
- tx.commit();
- fail("this should throw exception");
- }
- catch(Exception e)
- {
- // OK
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////
- /////////// Channel accepts reliable messages
- ///////////
-
- public void testNonRecoverableChannel_32_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_32_2_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- if (!queue.acceptReliableMessages())
- {
- // we test channels that accept reliable messages
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
- }
-
-
-
- //////
- ////// Transacted send and rollback
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_33() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_34() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testNonRecoverableChannel_35() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testNonRecoverableChannel_36() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testNonRecoverableChannel_36_mixed() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
-
-
-
- //
- // Recoverable channel
- //
-
- public void testRecoverableChannel_0() throws Exception
- {
- if (queue.isRecoverable())
- {
- assertTrue(queue.acceptReliableMessages());
- }
- }
-
- ////
- //// Zero receivers
- ////
-
- //////
- ////// Non-transacted send
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_1() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_2() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_3() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_4() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
-
- }
-
- //////
- ////// Transacted send and commit
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_5() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_6() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_7() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_8() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testRecoverableChannel_8_mixed() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- }
-
-
- //////
- ////// Transacted send and rollback
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_9() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_10() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_11() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_12() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testRecoverableChannel_12_mixed() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- tx.rollback();
-
- // still no messages in the channel
- assertEquals(0, queue.browse().size());
- }
-
- ////
- //// One receiver
- ////
-
- //////
- ////// ACKING receiver
- //////
-
- //////
- ////// Non-transacted send
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_13() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_14() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEqualSets(refs, received);
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_15() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_16() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertTrue(queue.browse().isEmpty());
- assertEqualSets(refs, r.getMessages());
- }
-
- //////
- ////// Transacted send and commit
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_17() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
-
- public void testRecoverableChannel_17_1() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- BrokenReceiver brokenReceiver = new BrokenReceiver(2);
- assertTrue(queue.add(brokenReceiver));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
-
- log.debug("sending message 1");
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- ref = createReference(1, false, "payload");
-
- log.debug("sending message 2");
- queue.handle(observer, ref, tx);
-
- ref = createReference(2, false, "payload");
-
- log.debug("sending message 3");
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- tx.commit();
-
- assertEquals(2, queue.browse().size());
- assertEquals(1, brokenReceiver.getMessages().size());
- }
-
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_18() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- assertEqualSets(refs, r.getMessages());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_19() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- List received = r.getMessages();
- assertEquals(1, received.size());
- Message sm = (Message)received.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_20() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- assertEqualSets(refs, r.getMessages());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testRecoverableChannel_20_mixed() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- assertEqualSets(refs, r.getMessages());
- }
-
-
- //////
- ////// Transacted send and rollback
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_21() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_22() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_23() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_24() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testRecoverableChannel_24_mixed() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an ACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- //////
- ////// NACKING receiver
- //////
-
- //////
- ////// Non-transacted send
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- public void testRecoverableChannel_25() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
- /**
- * The same test as before, but with a Receiver configured to acknowledge immediately
- * on the Delivery. Simulates a race condition in which the acknoledgment arrives before
- * the Delivery is returned to channel.
- *
- * @throws Throwable
- */
- public void testRecoverableChannel_25_race() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- r.setImmediateAsynchronousAcknowledgment(true);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- // the receiver should have returned a "done" delivery
- assertTrue(queue.browse().isEmpty());
-
- List messages = r.getMessages();
- assertEquals(1, messages.size());
- Message ackm = (Message)messages.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // an extra acknowledgment should be discarded
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and commit
- ////////////
-
- public void testRecoverableChannel_25_1() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- Transaction tx = tr.createTransaction();
-
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and rollback
- ////////////
-
- public void testRecoverableChannel_25_2() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, non-reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- Transaction tx = tr.createTransaction();
-
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- tx.rollback();
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- // acknowledge non-transactionally
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- //////////
- ////////// Multiple message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- public void testRecoverableChannel_26() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
-
- }
-
- ////////////
- //////////// Transacted acknowledgment and commit
- ////////////
-
- public void testRecoverableChannel_26_1() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- Transaction tx = tr.createTransaction();
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
- }
-
- assertEqualSets(refs, queue.browse());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and rollback
- ////////////
-
- public void testRecoverableChannel_26_2() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // non-transacted send, non-reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- Transaction tx = tr.createTransaction();
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
- }
-
- assertEqualSets(refs, queue.browse());
-
- tx.rollback();
-
- assertEqualSets(refs, queue.browse());
-
- // acknowledge non-transactionally
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- public void testRecoverableChannel_27() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
- /**
- * The same test as before, but with a Receiver configured to acknowledge immediately
- * on the Delivery. Simulates a race condition in which the acknoledgment arrives before
- * the Delivery is returned to channel.
- *
- * @throws Throwable
- */
- public void testRecoverableChannel_27_race() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- r.setImmediateAsynchronousAcknowledgment(true);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- // the receiver should have returned a "done" delivery
- assertTrue(queue.browse().isEmpty());
-
- List messages = r.getMessages();
- assertEquals(1, messages.size());
- Message ackm = (Message)messages.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // an extra acknowledgment should be discarded
-
- //TODO - why should it be discarded?
- //If you acknowledge twice surely this is a usage error?
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and commit
- ////////////
-
- public void testRecoverableChannel_27_1() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- Transaction tx = tr.createTransaction();
-
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- ////////////
- //////////// Transacted acknowledgment and rollback
- ////////////
-
- public void testRecoverableChannel_27_2() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-transacted send, reliable message, one message
- Delivery delivery = queue.handle(observer, ref, null);
-
- assertTrue(delivery.isDone());
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- Transaction tx = tr.createTransaction();
-
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- tx.rollback();
-
- delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- // acknowledge non-transactionally
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- //////////
- ////////// Multiple message
- //////////
-
- ////////////
- //////////// Non-transacted acknowledgment
- ////////////
-
- public void testRecoverableChannel_28() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
- ////////////
- //////////// Transacted acknowledgment and commit
- ////////////
-
- public void testRecoverableChannel_28_1() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- Transaction tx = tr.createTransaction();
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
- }
-
- assertEqualSets(refs, queue.browse());
-
- tx.commit();
-
- assertTrue(queue.browse().isEmpty());
- }
-
- ////////////
- //////////// Transacted acknowledgment and rollback
- ////////////
-
- public void testRecoverableChannel_28_2() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // non-transacted send, reliable message, multiple messages
- Delivery delivery = queue.handle(observer, refs[i], null);
-
- assertTrue(delivery.isDone());
- }
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- Transaction tx = tr.createTransaction();
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // transacted acknowledgment
- r.acknowledge(ackm, tx);
- }
-
- assertEqualSets(refs, queue.browse());
-
- tx.rollback();
-
- assertEqualSets(refs, queue.browse());
-
- // acknowledge non-transactionally
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- //////
- ////// Transacted send and commit
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_29() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_30() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_31() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- List delivering = queue.browse();
- assertEquals(1, delivering.size());
- assertEquals(0, ((Message)delivering.get(0)).getMessageID());
-
- List acknowledging = r.getMessages();
- assertEquals(1, acknowledging.size());
- Message ackm = (Message)acknowledging.get(0);
- assertEquals(0, ackm.getMessageID());
-
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
-
- assertTrue(queue.browse().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_32() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel yet
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testRecoverableChannel_32_mixed() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.commit();
-
- assertEqualSets(refs, queue.browse());
- assertEqualSets(refs, r.getMessages());
-
- for(Iterator i = r.getMessages().iterator(); i.hasNext();)
- {
- Message ackm = (Message)i.next();
- // non-transacted acknowledgment
- r.acknowledge(ackm, null);
- }
-
- assertTrue(queue.browse().isEmpty());
- }
-
-
- //////
- ////// Transacted send and rollback
- //////
-
- ////////
- //////// Non-reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_33() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, non-reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_34() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, false, "payload" + i);
-
- // transacted send, non-reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ////////
- //////// Reliable message
- ////////
-
- //////////
- ////////// One message
- //////////
-
- public void testRecoverableChannel_35() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- // transacted send, reliable message, one message
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, ref, tx);
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- //////////
- ////////// Multiple message
- //////////
-
- public void testRecoverableChannel_36() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- refs[i] = createReference(i, true, "payload" + i);
-
- // transacted send, reliable message, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- /**
- * This is a variation where I send a mixture of reliable and non-reliable messages,
- */
- public void testRecoverableChannel_36_mixed() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // add an NACKING receiver to the channel
- SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
- assertTrue(queue.add(r));
-
-
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- Transaction tx = tr.createTransaction();
-
- MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
- for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
- {
- // send a mixture of reliable and non-reliable messages
- refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
-
- // transacted send, reliable/non-reliable messages, multiple messages
- // for a transactional send, handle() return value is unspecified
- queue.handle(observer, refs[i], tx);
- }
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
-
- tx.rollback();
-
- // no messages in the channel
- assertEquals(0, queue.browse().size());
-
- // no message at the receiver
- assertTrue(r.getMessages().isEmpty());
- }
-
- ///////////////////////////////
- /////////////////////////////// Add receiver tests
- ///////////////////////////////
- ///////////////////////////////
- ///////////////////////////////
-
- //
- // Non-recoverable channel
- //
-
- ////
- //// Non-reliable message
- ////
-
- //////
- ////// Broken receiver
- //////
-
- public void testAddReceiver_1() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-recoverable channel, non-reliable message
- Delivery delivery = queue.handle(observer, ref, null);
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
-
- SimpleReceiver receiver = new SimpleReceiver("BrokenReceiver", SimpleReceiver.BROKEN);
- assertTrue(queue.add(receiver));
-
- stored = queue.browse();
- assertEquals(1, stored.size());
- Message sm = (Message)stored.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- assertTrue(receiver.getMessages().isEmpty());
- }
-
- //////
- ////// ACKING receiver
- //////
-
- public void testAddReceiver_2() throws Exception
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-recoverable channel, non-reliable message
- Delivery delivery = queue.handle(observer, ref, null);
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- SimpleReceiver receiver =
- new SimpleReceiver("ACKINGReceiver", SimpleReceiver.ACKING, queue);
- assertTrue(queue.add(receiver));
-
- assertEquals(1, queue.browse().size());
-
- // receiver explicitely asks for message
- receiver.requestMessages();
-
- assertTrue(queue.browse().isEmpty());
-
- List messages = receiver.getMessages();
- assertEquals(1, messages.size());
- Message sm = (Message)messages.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////
- ////// NACKING receiver
- //////
-
- public void testAddReceiver_3() throws Throwable
- {
- if (queue.isRecoverable())
- {
- // we test only non-recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, false, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-recoverable channel, non-reliable message
- Delivery delivery = queue.handle(observer, ref, null);
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- SimpleReceiver receiver =
- new SimpleReceiver("NACKINGReceiver", SimpleReceiver.ACCEPTING, queue);
- assertTrue(queue.add(receiver));
-
- assertEquals(1, queue.browse().size());
-
- // receiver explicitely asks for message
- receiver.requestMessages();
-
- assertEquals(1, queue.browse().size());
-
- List messages = receiver.getMessages();
- assertEquals(1, messages.size());
- Message sm = (Message)messages.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- receiver.acknowledge(sm, null);
-
- assertTrue(queue.browse().isEmpty());
-
- messages = receiver.getMessages();
- assertEquals(1, messages.size());
- sm = (Message)messages.iterator().next();
- assertFalse(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //
- // Recoverable channel
- //
-
- ////
- //// Reliable message
- ////
-
- public void testAddReceiver_4() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-recoverable channel, non-reliable message
- Delivery delivery = queue.handle(observer, ref, null);
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
-
- SimpleReceiver receiver = new SimpleReceiver("BrokenReceiver", SimpleReceiver.BROKEN);
- assertTrue(queue.add(receiver));
-
- stored = queue.browse();
- assertEquals(1, stored.size());
- Message sm = (Message)stored.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- assertTrue(receiver.getMessages().isEmpty());
- }
-
- //////
- ////// ACKING receiver
- //////
-
- public void testAddReceiver_5() throws Exception
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-recoverable channel, non-reliable message
- Delivery delivery = queue.handle(observer, ref, null);
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- SimpleReceiver receiver =
- new SimpleReceiver("ACKINGReceiver", SimpleReceiver.ACKING, queue);
- assertTrue(queue.add(receiver));
-
- // receiver explicitely asks for message
- receiver.requestMessages();
-
- assertTrue(queue.browse().isEmpty());
-
- List messages = receiver.getMessages();
- assertEquals(1, messages.size());
- Message sm = (Message)messages.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
- //////
- ////// NACKING receiver
- //////
-
- public void testAddReceiver_6() throws Throwable
- {
- if (!queue.isRecoverable())
- {
- // we test only recoverable channels now
- return;
- }
-
- // the channel has no receivers
- assertFalse(queue.iterator().hasNext());
-
- MessageReference ref = createReference(0, true, "payload");
- SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-
- // non-recoverable channel, non-reliable message
- Delivery delivery = queue.handle(observer, ref, null);
- assertTrue(delivery.isDone());
-
- List stored = queue.browse();
- assertEquals(1, stored.size());
-
- SimpleReceiver receiver =
- new SimpleReceiver("NACKINGReceiver", SimpleReceiver.ACCEPTING, queue);
- assertTrue(queue.add(receiver));
-
- assertEquals(1, queue.browse().size());
-
- // receiver explicitely asks for message
- receiver.requestMessages();
-
- assertEquals(1, queue.browse().size());
-
- List messages = receiver.getMessages();
- assertEquals(1, messages.size());
- Message sm = (Message)messages.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
-
- receiver.acknowledge(sm, null);
-
- assertTrue(queue.browse().isEmpty());
-
- messages = receiver.getMessages();
- assertEquals(1, messages.size());
- sm = (Message)messages.iterator().next();
- assertTrue(sm.isReliable());
- assertEquals(0, sm.getMessageID());
- }
-
-
-
-
- ///////////////////////////////
- /////////////////////////////// Channel crash tests
- ///////////////////////////////
-
-// public void testReliableChannelFailure() throws Throwable
-// {
-// if (!channel.isRecoverable())
-// {
-// return;
-// }
-//
-// SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
-// SimpleReceiver r = new SimpleReceiver("ONE", SimpleReceiver.NACKING);
-// channel.add(r);
-//
-// Routable m = Factory.createMessage("m0", true, "payload");
-// Delivery d = channel.handle(observer, ref, null);
-// assertTrue(d.isDone());
-//
-// List l = r.getMessages();
-// assertEquals(1, l.size());
-// Message rm = (Message)l.get(0);
-// assertEquals(rm.getMessageID(), m.getMessageID());
-//
-// crashChannel();
-//
-// recoverChannel();
-//
-// // make sure the recovered channel still holds the message
-//
-// l = channel.browse();
-// assertEquals(1, l.size());
-// MessageReference ref = (MessageReference)l.get(0);
-// rm = ref.getMessage();
-// assertEquals(rm.getMessageID(), m.getMessageID());
-//
-//
-// // TODO review this
-// try
-// {
-// r.acknowledge(m, null);
-// fail("should throw exception");
-// }
-// catch(IllegalStateException e)
-// {
-// // OK
-// }
-// }
-
-
- // Distributor tests ---------------------------------------------
-
- public void testAddOneReceiver()
- {
- Receiver r = new SimpleReceiver("ONE");
-
- assertTrue(queue.add(r));
- assertFalse(queue.add(r));
-
- assertTrue(queue.contains(r));
-
- Iterator i = queue.iterator();
- assertEquals(r, i.next());
- assertFalse(i.hasNext());
-
- queue.clear();
- assertFalse(queue.iterator().hasNext());
- }
-
- public void testRemoveInexistentReceiver()
- {
- assertFalse(queue.remove(new SimpleReceiver("INEXISTENT")));
- }
-
-
- // Package protected ---------------------------------------------
-
- // Protected -----------------------------------------------------
-
- protected abstract void crashChannel() throws Exception;
-
- protected abstract void recoverChannel() throws Exception;
-
- // Private -------------------------------------------------------
-
- private MessageReference createReference(long id, boolean reliable, Serializable payload)
- {
- return ms.reference(CoreMessageFactory.createCoreMessage(id, reliable, payload));
- }
-
- private MessageReference createReference(long id)
- {
- return ms.reference(CoreMessageFactory.createCoreMessage(id));
- }
-
- // Inner classes -------------------------------------------------
-
-}
Modified: trunk/tests/src/org/jboss/test/messaging/core/local/RecoverablePagingFilteredQueueTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/local/RecoverablePagingFilteredQueueTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/local/RecoverablePagingFilteredQueueTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -22,6 +22,7 @@
package org.jboss.test.messaging.core.local;
import org.jboss.messaging.core.local.PagingFilteredQueue;
+import org.jboss.test.messaging.core.local.base.PagingFilteredQueueTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Added: trunk/tests/src/org/jboss/test/messaging/core/local/base/PagingFilteredQueueTestBase.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/local/base/PagingFilteredQueueTestBase.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/local/base/PagingFilteredQueueTestBase.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -0,0 +1,6427 @@
+/*
+* JBoss, Home of Professional Open Source
+* Copyright 2005, JBoss Inc., and individual contributors as indicated
+* by the @authors tag. See the copyright.txt in the distribution for a
+* full listing of individual contributors.
+*
+* This is free software; you can redistribute it and/or modify it
+* under the terms of the GNU Lesser General Public License as
+* published by the Free Software Foundation; either version 2.1 of
+* the License, or (at your option) any later version.
+*
+* This software is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this software; if not, write to the Free
+* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+*/
+package org.jboss.test.messaging.core.local.base;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.jboss.messaging.core.Delivery;
+import org.jboss.messaging.core.Filter;
+import org.jboss.messaging.core.Message;
+import org.jboss.messaging.core.MessageReference;
+import org.jboss.messaging.core.Receiver;
+import org.jboss.messaging.core.local.PagingFilteredQueue;
+import org.jboss.messaging.core.message.CoreMessage;
+import org.jboss.messaging.core.plugin.IdManager;
+import org.jboss.messaging.core.plugin.JDBCPersistenceManager;
+import org.jboss.messaging.core.plugin.SimpleMessageStore;
+import org.jboss.messaging.core.plugin.contract.MessageStore;
+import org.jboss.messaging.core.plugin.contract.PersistenceManager;
+import org.jboss.messaging.core.tx.Transaction;
+import org.jboss.messaging.core.tx.TransactionRepository;
+import org.jboss.test.messaging.MessagingTestCase;
+import org.jboss.test.messaging.core.BrokenReceiver;
+import org.jboss.test.messaging.core.SimpleDeliveryObserver;
+import org.jboss.test.messaging.core.SimpleFilter;
+import org.jboss.test.messaging.core.SimpleReceiver;
+import org.jboss.test.messaging.tools.jmx.ServiceContainer;
+import org.jboss.test.messaging.util.CoreMessageFactory;
+
+import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
+
+/**
+ * The QueueTest test strategy is to try as many combination as it makes sense of the following
+ * variables:
+ *
+ * 1. The Queue can be non-recoverable or
+ * recoverable. A non-recoverable channel can accept reliable messages or not.
+ * 2. The Queue may have zero or one receivers (the behavior for more than one receiver depends
+ * on the particular router implementation).
+ * 3. The receiver may be ACKING or NACKING (the case when it throws unchecked exceptions is handled
+ * at the Router level).
+ * 4. The sender can send message(s) non-transactionally or transactionally (and then can commit
+ * or rollback the transaction).
+ * 5. The NACKING receiver can send acknowledgment(s) non-transactionally or transactionally (and
+ * then can commit or rollback the transaction).
+ * 6. The message can be non-reliable or reliable.
+ * 7. The sender can send one or multiple messages.
+ * 8. A recoverable channel may be crashed and tested if it successfully recovers.
+ *
+ * This test base also tests the Distributor interface.
+ *
+ * @author <a href="mailto:ovidiu at jboss.org">Ovidiu Feodorov</a>
+ * @author <a href="mailto:tim.fox at jboss.com">Tim Fox</a>
+ * @version <tt>$Revision: 1019 $</tt>
+ *
+ * $Id: ChannelTestBase.java 1019 2006-07-17 17:15:04Z timfox $
+ */
+public abstract class PagingFilteredQueueTestBase extends MessagingTestCase
+{
+ // Constants -----------------------------------------------------
+
+ public static final int NUMBER_OF_MESSAGES = 10;
+
+ // Static --------------------------------------------------------
+
+ // Attributes ----------------------------------------------------
+
+ protected PersistenceManager pm;
+
+ protected TransactionRepository tr;
+
+ protected MessageStore ms;
+
+ protected ServiceContainer sc;
+
+ protected PagingFilteredQueue queue;
+
+ // Constructors --------------------------------------------------
+
+ public PagingFilteredQueueTestBase(String name)
+ {
+ super(name);
+ }
+
+ // Public --------------------------------------------------------
+
+ public void setUp() throws Exception
+ {
+ super.setUp();
+
+ sc = new ServiceContainer("all,-remoting,-security");
+ sc.start();
+
+ pm =
+ new JDBCPersistenceManager(sc.getDataSource(), sc.getTransactionManager(), null,
+ true, true, true, 100);
+ pm.start();
+
+ tr = new TransactionRepository(pm, new IdManager("TRANSACTION_ID", 10, pm));
+ tr.start();
+
+ ms = new SimpleMessageStore();
+ ms.start();
+ }
+
+ public void tearDown() throws Exception
+ {
+ sc.stop();
+ sc = null;
+
+ ms = null;
+ tr = null;
+ super.tearDown();
+ }
+
+ public static void assertEqualSets(MessageReference[] a, List msgs)
+ {
+ assertEquals(a.length, msgs.size());
+ List l = new ArrayList(msgs);
+
+ for(int i = 0; i < a.length; i++)
+ {
+ for(Iterator j = l.iterator(); j.hasNext(); )
+ {
+ Object o = j.next();
+ Message m = (Message)o;
+
+
+ if (a[i].getMessageID() == m.getMessageID() &&
+ m.getPayload().equals(a[i].getMessage().getPayload()))
+ {
+ j.remove();
+ break;
+ }
+ }
+ }
+
+ if (!l.isEmpty())
+ {
+ fail("Messages " + l + " do not match!");
+ }
+ }
+
+ public static void assertEqualSets(Delivery[] a, List deliveries)
+ {
+ assertEquals(a.length, deliveries.size());
+ List l = new ArrayList(deliveries);
+
+ for(int i = 0; i < a.length; i++)
+ {
+ for(Iterator j = l.iterator(); j.hasNext(); )
+ {
+ Delivery d = (Delivery)j.next();
+ MessageReference ref = d.getReference();
+
+ if (a[i].getReference().getMessageID() == ref.getMessageID())
+ {
+ j.remove();
+ break;
+ }
+ }
+ }
+
+ if (!l.isEmpty())
+ {
+ fail("Deliveries " + l + " do not match!");
+ }
+ }
+
+
+ // Channel tests -------------------------------------------------
+
+
+ public void testWithFilter()
+ {
+ Filter f = new SimpleFilter(3);
+
+ PagingFilteredQueue queue = new PagingFilteredQueue("queue1", 1, ms, pm, true, false, new QueuedExecutor(), f);
+
+ Message m1 = new CoreMessage(1, false, 0, 0, (byte)0, null, null, 0);
+ Message m2 = new CoreMessage(2, false, 0, 0, (byte)0, null, null, 0);
+ Message m3 = new CoreMessage(3, false, 0, 0, (byte)0, null, null, 0);
+ Message m4 = new CoreMessage(4, false, 0, 0, (byte)0, null, null, 0);
+ Message m5 = new CoreMessage(5, false, 0, 0, (byte)0, null, null, 0);
+
+ MessageReference ref1 = ms.reference(m1);
+ MessageReference ref2 = ms.reference(m2);
+ MessageReference ref3 = ms.reference(m3);
+ MessageReference ref4 = ms.reference(m4);
+ MessageReference ref5 = ms.reference(m5);
+
+ Delivery del = queue.handle(null, ref1, null);
+ assertFalse(del.isSelectorAccepted());
+
+ del = queue.handle(null, ref2, null);
+ assertFalse(del.isSelectorAccepted());
+
+ del = queue.handle(null, ref3, null);
+ assertTrue(del.isSelectorAccepted());
+
+ del = queue.handle(null, ref4, null);
+ assertFalse(del.isSelectorAccepted());
+
+ del = queue.handle(null, ref5, null);
+ assertFalse(del.isSelectorAccepted());
+ }
+
+
+ public void testUnreliableSynchronousDeliveryTwoReceivers() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+ SimpleReceiver r1 = new SimpleReceiver("ONE", SimpleReceiver.ACKING);
+ SimpleReceiver r2 = new SimpleReceiver("TWO", SimpleReceiver.ACKING);
+
+ queue.add(r1);
+ queue.add(r2);
+
+ Delivery d = queue.handle(observer, createReference(0, false, "payload"), null);
+
+ assertTrue(d.isDone());
+ List l1 = r1.getMessages();
+ List l2 = r2.getMessages();
+ if (l2.isEmpty())
+ {
+ assertEquals(1, l1.size());
+ Message m = (Message)l1.get(0);
+ assertEquals("payload", m.getPayload());
+ }
+ else
+ {
+ assertTrue(l1.isEmpty());
+ assertEquals(1, l2.size());
+ Message m = (Message)l2.get(0);
+ assertEquals("payload", m.getPayload());
+ }
+ }
+
+
+ public void testReliableSynchronousDeliveryTwoReceivers() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+ SimpleReceiver r1 = new SimpleReceiver("ONE", SimpleReceiver.ACKING);
+ SimpleReceiver r2 = new SimpleReceiver("TWO", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r1));
+ assertTrue(queue.add(r2));
+
+ Delivery d = queue.handle(observer, createReference(0, true, "payload"), null);
+
+ assertTrue(d.isDone());
+ List l1 = r1.getMessages();
+ List l2 = r2.getMessages();
+ if (l2.isEmpty())
+ {
+ assertEquals(1, l1.size());
+ Message m = (Message)l1.get(0);
+ assertEquals("payload", m.getPayload());
+ }
+ else
+ {
+ assertTrue(l1.isEmpty());
+ assertEquals(1, l2.size());
+ Message m = (Message)l2.get(0);
+ assertEquals("payload", m.getPayload());
+ }
+ }
+
+ /*
+ * If a channel has a set a receiver and remove is called with a different receiver
+ * need to ensure the receiver is not removed (since it doesn't match)
+ */
+ public void testRemoveDifferentReceiver() throws Exception
+ {
+ Receiver receiver1 = new SimpleReceiver();
+
+ Receiver receiver2 = new SimpleReceiver();
+
+ assertFalse(queue.iterator().hasNext());
+
+ queue.add(receiver1);
+
+ assertTrue(queue.contains(receiver1));
+
+ queue.remove(receiver1);
+
+ assertFalse(queue.iterator().hasNext());
+
+ assertFalse(queue.contains(receiver1));
+
+ queue.add(receiver1);
+
+ assertTrue(queue.contains(receiver1));
+
+ queue.remove(receiver2);
+
+ assertTrue(queue.contains(receiver1));
+
+ }
+
+ public void testClosedChannel() throws Exception
+ {
+ queue.close();
+ try
+ {
+ queue.handle(null, createReference(0), null);
+ fail("should throw exception");
+ }
+ catch(IllegalStateException e)
+ {
+ //OK
+ }
+ }
+
+ public void testHandleNullRoutable() throws Exception
+ {
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+ assertNull(queue.handle(observer, null, null));
+ }
+
+ //////////////////////////////////
+ ////////////////////////////////// Test matrix
+ //////////////////////////////////
+
+ //
+ // Non-recoverable channel
+ //
+
+ ////
+ //// Zero receivers
+ ////
+
+ //////
+ ////// Non-transacted send
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
+ queue.add(receiver);
+ queue.deliver(true);
+ assertEquals(1, receiver.getMessages().size());
+ assertEquals(0, ((Message)receiver.getMessages().get(0)).getMessageID());
+
+ queue.deliver(true);
+ assertEquals(1, receiver.getMessages().size());
+
+
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ List stored = queue.browse();
+ assertEqualSets(refs, stored);
+
+ SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
+ queue.add(receiver);
+ queue.deliver(true);
+ assertEquals(10, receiver.getMessages().size());
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ assertEquals(i, ((Message)receiver.getMessages().get(i)).getMessageID());
+ }
+ receiver.clear();
+
+ queue.deliver(true);
+ assertEquals(0, receiver.getMessages().size());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_3_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ // the channel must not accept the message
+ assertNull(delivery);
+
+ assertTrue(queue.browse().isEmpty());
+
+ queue.deliver(true);
+
+ Receiver r = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
+
+ queue.add(r);
+
+ queue.deliver(true);
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_3_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ queue.deliver(true);
+
+ SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
+ queue.add(receiver);
+ queue.deliver(true);
+ assertEquals(1, receiver.getMessages().size());
+ assertEquals(0, ((Message)receiver.getMessages().get(0)).getMessageID());
+
+ queue.deliver(true);
+ assertEquals(1, receiver.getMessages().size());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_4_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ // the channel must not accept the message
+ assertNull(delivery);
+
+ queue.deliver(true);
+
+ Receiver r = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
+
+ queue.add(r);
+
+ queue.deliver(true);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_4_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ SimpleReceiver receiver = new SimpleReceiver("ACKING", SimpleReceiver.ACKING);
+ queue.add(receiver);
+ queue.deliver(true);
+ assertEquals(10, receiver.getMessages().size());
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ assertEquals(i, ((Message)receiver.getMessages().get(i)).getMessageID());
+ }
+ receiver.clear();
+
+ queue.deliver(true);
+ assertEquals(0, receiver.getMessages().size());
+ }
+
+
+
+ //////
+ ////// Transacted send and commit
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_5() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_6() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ List stored = queue.browse();
+ assertEqualSets(refs, stored);
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_7_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_7_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_8_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_8_1_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ }
+
+ public void testNonRecoverableChannel_8_1_mixed_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES * 2];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i + NUMBER_OF_MESSAGES] = createReference(i + NUMBER_OF_MESSAGES , true, "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i + NUMBER_OF_MESSAGES], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ }
+
+
+ public void testNonRecoverableChannel_8_1_mixed_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES * 2];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i + NUMBER_OF_MESSAGES] = createReference(i + NUMBER_OF_MESSAGES , true, "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i + NUMBER_OF_MESSAGES], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_8_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_8_2_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ }
+
+
+ //////
+ ////// Transacted send and rollback
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_9() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_10() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_11() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_12() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_12_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ ////
+ //// One receiver
+ ////
+
+ //////
+ ////// ACKING receiver
+ //////
+
+ //////
+ ////// Non-transacted send
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_13() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_14() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEqualSets(refs, received);
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_15_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertNull(delivery);
+
+ assertTrue(queue.browse().isEmpty());
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_15_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_16_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertNull(delivery);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_16_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ //////
+ ////// Transacted send and commit
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_17() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_18() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_19_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_19_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_20_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_20_1_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_20_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_20_2_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ //////
+ ////// Transacted send and rollback
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_21() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_22() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_23() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_24() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_24_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ //////
+ ////// NACKING receiver
+ //////
+
+ //////
+ ////// Non-transacted send
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ public void testNonRecoverableChannel_25() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ /**
+ * The same test as before, but with a Receiver configured to acknowledge immediately
+ * on the Delivery. Simulates a race condition in which the acknoledgment arrives before
+ * the Delivery is returned to channel.
+ *
+ * @throws Throwable
+ */
+ public void testNonRecoverableChannel_25_race() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ r.setImmediateAsynchronousAcknowledgment(true);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ // the receiver should have returned a "done" delivery
+ assertTrue(queue.browse().isEmpty());
+
+ List messages = r.getMessages();
+ assertEquals(1, messages.size());
+ Message ackm = (Message)messages.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // an extra acknowledgment should be discarded
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and commit
+ ////////////
+
+ public void testNonRecoverableChannel_25_1() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and rollback
+ ////////////
+
+ public void testNonRecoverableChannel_25_2() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ tx.rollback();
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ // acknowledge non-transactionally
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ public void testNonRecoverableChannel_26() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+
+ }
+
+ ////////////
+ //////////// Transacted acknowledgment and commit
+ ////////////
+
+ public void testNonRecoverableChannel_26_1() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ Transaction tx = tr.createTransaction();
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and rollback
+ ////////////
+
+ public void testNonRecoverableChannel_26_2() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ Transaction tx = tr.createTransaction();
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ tx.rollback();
+
+ assertEqualSets(refs, queue.browse());
+
+ // acknowledge non-transactionally
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_27_1_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ // not accepted by the channel
+ assertNull(delivery);
+ assertTrue(queue.browse().isEmpty());
+ assertTrue(r.getMessages().isEmpty());
+
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_27_1_2() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message rm = (Message)received.iterator().next();
+ assertTrue(rm.isReliable());
+ assertEquals(0, rm.getMessageID());
+
+ r.acknowledge(rm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment
+ ////////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+
+ // Doesn't make sense, the message won't be accepted anyway.
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+
+ public void testNonRecoverableChannel_27_2_2() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message rm = (Message)received.iterator().next();
+ assertTrue(rm.isReliable());
+ assertEquals(0, rm.getMessageID());
+
+ Transaction tx = tr.createTransaction();
+
+ r.acknowledge(rm, tx);
+
+ stored = queue.browse();
+ assertEquals(1, stored.size());
+ sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_28_1_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ // not accepted by the channel
+ assertNull(delivery);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_28_1_2() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment
+ ////////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ // Doesn't make sense, the message won't be accepted anyway.
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_28_2_2() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ Transaction tx = tr.createTransaction();
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ r.acknowledge(ackm, tx);
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ //////
+ ////// Transacted send and commit
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_29() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_30() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_31_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel does accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_31_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message rm = (Message)received.iterator().next();
+ assertTrue(rm.isReliable());
+ assertEquals(0, rm.getMessageID());
+ }
+
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ///////////
+ /////////// Channel does NOT accept reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_32_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_32_1_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (queue.acceptReliableMessages())
+ {
+ // we test channels that don't accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ try
+ {
+ tx.commit();
+ fail("this should throw exception");
+ }
+ catch(Exception e)
+ {
+ // OK
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////
+ /////////// Channel accepts reliable messages
+ ///////////
+
+ public void testNonRecoverableChannel_32_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_32_2_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ if (!queue.acceptReliableMessages())
+ {
+ // we test channels that accept reliable messages
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+ }
+
+
+
+ //////
+ ////// Transacted send and rollback
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_33() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_34() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testNonRecoverableChannel_35() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testNonRecoverableChannel_36() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testNonRecoverableChannel_36_mixed() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+
+
+
+ //
+ // Recoverable channel
+ //
+
+ public void testRecoverableChannel_0() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ assertTrue(queue.acceptReliableMessages());
+ }
+ }
+
+ ////
+ //// Zero receivers
+ ////
+
+ //////
+ ////// Non-transacted send
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_1() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_2() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_3() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_4() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ }
+
+ //////
+ ////// Transacted send and commit
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_5() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_6() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_7() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_8() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testRecoverableChannel_8_mixed() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ }
+
+
+ //////
+ ////// Transacted send and rollback
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_9() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_10() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_11() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_12() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testRecoverableChannel_12_mixed() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ tx.rollback();
+
+ // still no messages in the channel
+ assertEquals(0, queue.browse().size());
+ }
+
+ ////
+ //// One receiver
+ ////
+
+ //////
+ ////// ACKING receiver
+ //////
+
+ //////
+ ////// Non-transacted send
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_13() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_14() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEqualSets(refs, received);
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_15() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_16() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ //////
+ ////// Transacted send and commit
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_17() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+
+ public void testRecoverableChannel_17_1() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ BrokenReceiver brokenReceiver = new BrokenReceiver(2);
+ assertTrue(queue.add(brokenReceiver));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+
+ log.debug("sending message 1");
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ ref = createReference(1, false, "payload");
+
+ log.debug("sending message 2");
+ queue.handle(observer, ref, tx);
+
+ ref = createReference(2, false, "payload");
+
+ log.debug("sending message 3");
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ tx.commit();
+
+ assertEquals(2, queue.browse().size());
+ assertEquals(1, brokenReceiver.getMessages().size());
+ }
+
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_18() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_19() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ List received = r.getMessages();
+ assertEquals(1, received.size());
+ Message sm = (Message)received.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_20() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ assertEqualSets(refs, r.getMessages());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testRecoverableChannel_20_mixed() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ assertEqualSets(refs, r.getMessages());
+ }
+
+
+ //////
+ ////// Transacted send and rollback
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_21() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_22() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_23() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_24() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testRecoverableChannel_24_mixed() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an ACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("AckingReceiver", SimpleReceiver.ACKING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ //////
+ ////// NACKING receiver
+ //////
+
+ //////
+ ////// Non-transacted send
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ public void testRecoverableChannel_25() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ /**
+ * The same test as before, but with a Receiver configured to acknowledge immediately
+ * on the Delivery. Simulates a race condition in which the acknoledgment arrives before
+ * the Delivery is returned to channel.
+ *
+ * @throws Throwable
+ */
+ public void testRecoverableChannel_25_race() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ r.setImmediateAsynchronousAcknowledgment(true);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ // the receiver should have returned a "done" delivery
+ assertTrue(queue.browse().isEmpty());
+
+ List messages = r.getMessages();
+ assertEquals(1, messages.size());
+ Message ackm = (Message)messages.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // an extra acknowledgment should be discarded
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and commit
+ ////////////
+
+ public void testRecoverableChannel_25_1() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and rollback
+ ////////////
+
+ public void testRecoverableChannel_25_2() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, non-reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ tx.rollback();
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ // acknowledge non-transactionally
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ public void testRecoverableChannel_26() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+
+ }
+
+ ////////////
+ //////////// Transacted acknowledgment and commit
+ ////////////
+
+ public void testRecoverableChannel_26_1() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ Transaction tx = tr.createTransaction();
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and rollback
+ ////////////
+
+ public void testRecoverableChannel_26_2() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // non-transacted send, non-reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ Transaction tx = tr.createTransaction();
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ tx.rollback();
+
+ assertEqualSets(refs, queue.browse());
+
+ // acknowledge non-transactionally
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ public void testRecoverableChannel_27() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ /**
+ * The same test as before, but with a Receiver configured to acknowledge immediately
+ * on the Delivery. Simulates a race condition in which the acknoledgment arrives before
+ * the Delivery is returned to channel.
+ *
+ * @throws Throwable
+ */
+ public void testRecoverableChannel_27_race() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ r.setImmediateAsynchronousAcknowledgment(true);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ // the receiver should have returned a "done" delivery
+ assertTrue(queue.browse().isEmpty());
+
+ List messages = r.getMessages();
+ assertEquals(1, messages.size());
+ Message ackm = (Message)messages.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // an extra acknowledgment should be discarded
+
+ //TODO - why should it be discarded?
+ //If you acknowledge twice surely this is a usage error?
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and commit
+ ////////////
+
+ public void testRecoverableChannel_27_1() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ ////////////
+ //////////// Transacted acknowledgment and rollback
+ ////////////
+
+ public void testRecoverableChannel_27_2() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-transacted send, reliable message, one message
+ Delivery delivery = queue.handle(observer, ref, null);
+
+ assertTrue(delivery.isDone());
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ tx.rollback();
+
+ delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ // acknowledge non-transactionally
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ ////////////
+ //////////// Non-transacted acknowledgment
+ ////////////
+
+ public void testRecoverableChannel_28() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ ////////////
+ //////////// Transacted acknowledgment and commit
+ ////////////
+
+ public void testRecoverableChannel_28_1() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ Transaction tx = tr.createTransaction();
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ tx.commit();
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ ////////////
+ //////////// Transacted acknowledgment and rollback
+ ////////////
+
+ public void testRecoverableChannel_28_2() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // non-transacted send, reliable message, multiple messages
+ Delivery delivery = queue.handle(observer, refs[i], null);
+
+ assertTrue(delivery.isDone());
+ }
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ Transaction tx = tr.createTransaction();
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // transacted acknowledgment
+ r.acknowledge(ackm, tx);
+ }
+
+ assertEqualSets(refs, queue.browse());
+
+ tx.rollback();
+
+ assertEqualSets(refs, queue.browse());
+
+ // acknowledge non-transactionally
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ //////
+ ////// Transacted send and commit
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_29() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_30() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_31() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ List delivering = queue.browse();
+ assertEquals(1, delivering.size());
+ assertEquals(0, ((Message)delivering.get(0)).getMessageID());
+
+ List acknowledging = r.getMessages();
+ assertEquals(1, acknowledging.size());
+ Message ackm = (Message)acknowledging.get(0);
+ assertEquals(0, ackm.getMessageID());
+
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_32() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel yet
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testRecoverableChannel_32_mixed() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.commit();
+
+ assertEqualSets(refs, queue.browse());
+ assertEqualSets(refs, r.getMessages());
+
+ for(Iterator i = r.getMessages().iterator(); i.hasNext();)
+ {
+ Message ackm = (Message)i.next();
+ // non-transacted acknowledgment
+ r.acknowledge(ackm, null);
+ }
+
+ assertTrue(queue.browse().isEmpty());
+ }
+
+
+ //////
+ ////// Transacted send and rollback
+ //////
+
+ ////////
+ //////// Non-reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_33() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, non-reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_34() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, false, "payload" + i);
+
+ // transacted send, non-reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ////////
+ //////// Reliable message
+ ////////
+
+ //////////
+ ////////// One message
+ //////////
+
+ public void testRecoverableChannel_35() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ // transacted send, reliable message, one message
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, ref, tx);
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ //////////
+ ////////// Multiple message
+ //////////
+
+ public void testRecoverableChannel_36() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ refs[i] = createReference(i, true, "payload" + i);
+
+ // transacted send, reliable message, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ /**
+ * This is a variation where I send a mixture of reliable and non-reliable messages,
+ */
+ public void testRecoverableChannel_36_mixed() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // add an NACKING receiver to the channel
+ SimpleReceiver r = new SimpleReceiver("NackingReceiver", SimpleReceiver.ACCEPTING);
+ assertTrue(queue.add(r));
+
+
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ Transaction tx = tr.createTransaction();
+
+ MessageReference[] refs = new MessageReference[NUMBER_OF_MESSAGES];
+ for(int i = 0; i < NUMBER_OF_MESSAGES; i++)
+ {
+ // send a mixture of reliable and non-reliable messages
+ refs[i] = createReference(i, (i % 2 == 1), "payload" + i);
+
+ // transacted send, reliable/non-reliable messages, multiple messages
+ // for a transactional send, handle() return value is unspecified
+ queue.handle(observer, refs[i], tx);
+ }
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+
+ tx.rollback();
+
+ // no messages in the channel
+ assertEquals(0, queue.browse().size());
+
+ // no message at the receiver
+ assertTrue(r.getMessages().isEmpty());
+ }
+
+ ///////////////////////////////
+ /////////////////////////////// Add receiver tests
+ ///////////////////////////////
+ ///////////////////////////////
+ ///////////////////////////////
+
+ //
+ // Non-recoverable channel
+ //
+
+ ////
+ //// Non-reliable message
+ ////
+
+ //////
+ ////// Broken receiver
+ //////
+
+ public void testAddReceiver_1() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-recoverable channel, non-reliable message
+ Delivery delivery = queue.handle(observer, ref, null);
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+
+ SimpleReceiver receiver = new SimpleReceiver("BrokenReceiver", SimpleReceiver.BROKEN);
+ assertTrue(queue.add(receiver));
+
+ stored = queue.browse();
+ assertEquals(1, stored.size());
+ Message sm = (Message)stored.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ assertTrue(receiver.getMessages().isEmpty());
+ }
+
+ //////
+ ////// ACKING receiver
+ //////
+
+ public void testAddReceiver_2() throws Exception
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-recoverable channel, non-reliable message
+ Delivery delivery = queue.handle(observer, ref, null);
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ SimpleReceiver receiver =
+ new SimpleReceiver("ACKINGReceiver", SimpleReceiver.ACKING, queue);
+ assertTrue(queue.add(receiver));
+
+ assertEquals(1, queue.browse().size());
+
+ // receiver explicitely asks for message
+ receiver.requestMessages();
+
+ assertTrue(queue.browse().isEmpty());
+
+ List messages = receiver.getMessages();
+ assertEquals(1, messages.size());
+ Message sm = (Message)messages.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////
+ ////// NACKING receiver
+ //////
+
+ public void testAddReceiver_3() throws Throwable
+ {
+ if (queue.isRecoverable())
+ {
+ // we test only non-recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, false, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-recoverable channel, non-reliable message
+ Delivery delivery = queue.handle(observer, ref, null);
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ SimpleReceiver receiver =
+ new SimpleReceiver("NACKINGReceiver", SimpleReceiver.ACCEPTING, queue);
+ assertTrue(queue.add(receiver));
+
+ assertEquals(1, queue.browse().size());
+
+ // receiver explicitely asks for message
+ receiver.requestMessages();
+
+ assertEquals(1, queue.browse().size());
+
+ List messages = receiver.getMessages();
+ assertEquals(1, messages.size());
+ Message sm = (Message)messages.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ receiver.acknowledge(sm, null);
+
+ assertTrue(queue.browse().isEmpty());
+
+ messages = receiver.getMessages();
+ assertEquals(1, messages.size());
+ sm = (Message)messages.iterator().next();
+ assertFalse(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //
+ // Recoverable channel
+ //
+
+ ////
+ //// Reliable message
+ ////
+
+ public void testAddReceiver_4() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-recoverable channel, non-reliable message
+ Delivery delivery = queue.handle(observer, ref, null);
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+
+ SimpleReceiver receiver = new SimpleReceiver("BrokenReceiver", SimpleReceiver.BROKEN);
+ assertTrue(queue.add(receiver));
+
+ stored = queue.browse();
+ assertEquals(1, stored.size());
+ Message sm = (Message)stored.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ assertTrue(receiver.getMessages().isEmpty());
+ }
+
+ //////
+ ////// ACKING receiver
+ //////
+
+ public void testAddReceiver_5() throws Exception
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-recoverable channel, non-reliable message
+ Delivery delivery = queue.handle(observer, ref, null);
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ SimpleReceiver receiver =
+ new SimpleReceiver("ACKINGReceiver", SimpleReceiver.ACKING, queue);
+ assertTrue(queue.add(receiver));
+
+ // receiver explicitely asks for message
+ receiver.requestMessages();
+
+ assertTrue(queue.browse().isEmpty());
+
+ List messages = receiver.getMessages();
+ assertEquals(1, messages.size());
+ Message sm = (Message)messages.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+ //////
+ ////// NACKING receiver
+ //////
+
+ public void testAddReceiver_6() throws Throwable
+ {
+ if (!queue.isRecoverable())
+ {
+ // we test only recoverable channels now
+ return;
+ }
+
+ // the channel has no receivers
+ assertFalse(queue.iterator().hasNext());
+
+ MessageReference ref = createReference(0, true, "payload");
+ SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+
+ // non-recoverable channel, non-reliable message
+ Delivery delivery = queue.handle(observer, ref, null);
+ assertTrue(delivery.isDone());
+
+ List stored = queue.browse();
+ assertEquals(1, stored.size());
+
+ SimpleReceiver receiver =
+ new SimpleReceiver("NACKINGReceiver", SimpleReceiver.ACCEPTING, queue);
+ assertTrue(queue.add(receiver));
+
+ assertEquals(1, queue.browse().size());
+
+ // receiver explicitely asks for message
+ receiver.requestMessages();
+
+ assertEquals(1, queue.browse().size());
+
+ List messages = receiver.getMessages();
+ assertEquals(1, messages.size());
+ Message sm = (Message)messages.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+
+ receiver.acknowledge(sm, null);
+
+ assertTrue(queue.browse().isEmpty());
+
+ messages = receiver.getMessages();
+ assertEquals(1, messages.size());
+ sm = (Message)messages.iterator().next();
+ assertTrue(sm.isReliable());
+ assertEquals(0, sm.getMessageID());
+ }
+
+
+
+
+ ///////////////////////////////
+ /////////////////////////////// Channel crash tests
+ ///////////////////////////////
+
+// public void testReliableChannelFailure() throws Throwable
+// {
+// if (!channel.isRecoverable())
+// {
+// return;
+// }
+//
+// SimpleDeliveryObserver observer = new SimpleDeliveryObserver();
+// SimpleReceiver r = new SimpleReceiver("ONE", SimpleReceiver.NACKING);
+// channel.add(r);
+//
+// Routable m = Factory.createMessage("m0", true, "payload");
+// Delivery d = channel.handle(observer, ref, null);
+// assertTrue(d.isDone());
+//
+// List l = r.getMessages();
+// assertEquals(1, l.size());
+// Message rm = (Message)l.get(0);
+// assertEquals(rm.getMessageID(), m.getMessageID());
+//
+// crashChannel();
+//
+// recoverChannel();
+//
+// // make sure the recovered channel still holds the message
+//
+// l = channel.browse();
+// assertEquals(1, l.size());
+// MessageReference ref = (MessageReference)l.get(0);
+// rm = ref.getMessage();
+// assertEquals(rm.getMessageID(), m.getMessageID());
+//
+//
+// // TODO review this
+// try
+// {
+// r.acknowledge(m, null);
+// fail("should throw exception");
+// }
+// catch(IllegalStateException e)
+// {
+// // OK
+// }
+// }
+
+
+ // Distributor tests ---------------------------------------------
+
+ public void testAddOneReceiver()
+ {
+ Receiver r = new SimpleReceiver("ONE");
+
+ assertTrue(queue.add(r));
+ assertFalse(queue.add(r));
+
+ assertTrue(queue.contains(r));
+
+ Iterator i = queue.iterator();
+ assertEquals(r, i.next());
+ assertFalse(i.hasNext());
+
+ queue.clear();
+ assertFalse(queue.iterator().hasNext());
+ }
+
+ public void testRemoveInexistentReceiver()
+ {
+ assertFalse(queue.remove(new SimpleReceiver("INEXISTENT")));
+ }
+
+
+ // Package protected ---------------------------------------------
+
+ // Protected -----------------------------------------------------
+
+ protected abstract void crashChannel() throws Exception;
+
+ protected abstract void recoverChannel() throws Exception;
+
+ // Private -------------------------------------------------------
+
+ private MessageReference createReference(long id, boolean reliable, Serializable payload)
+ {
+ return ms.reference(CoreMessageFactory.createCoreMessage(id, reliable, payload));
+ }
+
+ private MessageReference createReference(long id)
+ {
+ return ms.reference(CoreMessageFactory.createCoreMessage(id));
+ }
+
+ // Inner classes -------------------------------------------------
+
+}
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_2PCTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_2PCTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_2PCTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -29,6 +29,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_NTTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_NTTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_NTTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -28,6 +28,7 @@
import org.jboss.messaging.core.local.PagingFilteredQueue;
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_TTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_TTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_NP_TTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -29,6 +29,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_2PCTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_2PCTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_2PCTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -29,6 +29,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_NTTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_NTTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_NTTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -28,6 +28,7 @@
import org.jboss.messaging.core.local.PagingFilteredQueue;
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_TTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_TTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/ChannelShare_P_TTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -29,6 +29,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Deleted: trunk/tests/src/org/jboss/test/messaging/core/paging/PagingStateTestBase.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/PagingStateTestBase.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/PagingStateTestBase.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -1,572 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source
- * Copyright 2005, JBoss Inc., and individual contributors as indicated
- * by the @authors tag. See the copyright.txt in the distribution for a
- * full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.test.messaging.core.paging;
-
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.List;
-
-import javax.naming.InitialContext;
-import javax.sql.DataSource;
-import javax.transaction.TransactionManager;
-
-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.SimpleDelivery;
-import org.jboss.messaging.core.plugin.IdManager;
-import org.jboss.messaging.core.plugin.JDBCPersistenceManager;
-import org.jboss.messaging.core.plugin.SimpleMessageStore;
-import org.jboss.messaging.core.plugin.contract.PersistenceManager;
-import org.jboss.messaging.core.tx.Transaction;
-import org.jboss.messaging.core.tx.TransactionRepository;
-import org.jboss.messaging.core.tx.XidImpl;
-import org.jboss.test.messaging.MessagingTestCase;
-import org.jboss.test.messaging.tools.jmx.ServiceContainer;
-import org.jboss.tm.TransactionManagerService;
-import org.jboss.util.id.GUID;
-
-/**
- *
- * A PagingStateTestBase.
- *
- * @author <a href="tim.fox at jboss.com">Tim Fox</a>
- * @version 1.1
- *
- * PagingStateTestBase.java,v 1.1 2006/03/22 10:23:35 timfox Exp
- */
-public class PagingStateTestBase extends MessagingTestCase
-{
- // Constants -----------------------------------------------------
-
- // Static --------------------------------------------------------
-
- // Attributes ----------------------------------------------------
-
- protected ServiceContainer sc;
- protected PersistenceManager pm;
- protected SimpleMessageStore ms;
- protected TransactionRepository tr;
-
- // Constructors --------------------------------------------------
-
- public PagingStateTestBase(String name)
- {
- super(name);
- }
-
- // Public --------------------------------------------------------
-
- public void testEmpty()
- {
-
- }
-
- public void setUp() throws Exception
- {
- super.setUp();
-
- sc = new ServiceContainer("all,-remoting,-security");
- sc.start();
-
- pm =
- new JDBCPersistenceManager(sc.getDataSource(), sc.getTransactionManager(), null,
- true, true, true, 100);
- pm.start();
-
- tr = new TransactionRepository(pm, new IdManager("TRANSACTION_ID", 10, pm));
- tr.start();
-
- ms = new SimpleMessageStore();
- ms.start();
- }
-
-
- public void tearDown() throws Exception
- {
- pm.stop();
- tr.stop();
- ms.stop();
- sc.stop();
-
- super.tearDown();
- }
-
- protected Transaction createXATx() throws Exception
- {
- XidImpl xid = new XidImpl(new GUID().toString().getBytes(), 345, new GUID().toString().getBytes());
-
- return tr.createTransaction(xid);
- }
-
- protected void assertSameIds(List ids, MessageReference[] refs, int start, int end)
- {
- assertNotNull(ids);
- assertEquals(ids.size(), end - start + 1);
- Iterator iter = ids.iterator();
- int i = start;
- while (iter.hasNext())
- {
- Long id = (Long)iter.next();
- assertEquals(refs[i].getMessageID(), id.longValue());
- i++;
- }
- }
-
- class ConsumingReceiver implements Receiver
- {
- int numToConsume;
-
- 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, MessageReference ref, Transaction tx)
- {
- if (count >= numToConsume)
- {
- return null;
- }
-
- assertEquals(refs[consumeCount + count].getMessageID(), ref.getMessageID());
-
- SimpleDelivery del = new SimpleDelivery(observer, ref);
-
- dels[count] = del;
-
- count++;
-
- if (count == numToConsume)
- {
- notify();
- }
-
- 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, MessageReference ref, Transaction tx)
- {
- if (count == numToCancel)
- {
- return null;
- }
-
- SimpleDelivery del = new SimpleDelivery(observer, ref);
-
- toCancel[count] = del;
-
- count++;
-
- if (count == numToCancel)
- {
- notify();
- }
-
- return del;
-
- }
-
- public synchronized SimpleDelivery[] getToCancel() throws Exception
- {
- // Wait for them all to arrive first
-
- while (count < numToCancel)
- {
- wait(1000);
-
- if (count < numToCancel)
- {
- PagingStateTestBase.fail();
- return null;
- }
- }
-
- 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
- {
- 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
- {
- 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);
- }
-
- 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);
- }
-
-
- protected List getReferenceIdsOrderedByOrd(long channelId) throws Exception
- {
- InitialContext ctx = new InitialContext();
-
- TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
- DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
-
- javax.transaction.Transaction txOld = mgr.suspend();
- mgr.begin();
-
- Connection conn = ds.getConnection();
-
- List msgIds = new ArrayList();
-
- String sql = "SELECT MESSAGEID, ORD, PAGE_ORD FROM JMS_MESSAGE_REFERENCE WHERE CHANNELID=? ORDER BY ORD";
- PreparedStatement ps = conn.prepareStatement(sql);
- ps.setLong(1, channelId);
-
- ResultSet rs = ps.executeQuery();
-
- while (rs.next())
- {
- long msgId = rs.getLong(1);
- long ord = rs.getLong(2);
-
- msgIds.add(new Long(msgId));
- }
- rs.close();
- ps.close();
-
- conn.close();
-
- mgr.commit();
-
- if (txOld != null)
- {
- mgr.resume(txOld);
- }
-
- return msgIds;
- }
-
- protected List getReferenceIdsOrderedByPageOrd(long channelId) throws Exception
- {
- InitialContext ctx = new InitialContext();
-
- TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
- DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
-
- javax.transaction.Transaction txOld = mgr.suspend();
- mgr.begin();
-
- Connection conn = ds.getConnection();
-
- List msgIds = new ArrayList();
-
- //log.info("channel id:" + channelId);
-
- String sql = "SELECT MESSAGEID, ORD, PAGE_ORD FROM JMS_MESSAGE_REFERENCE WHERE CHANNELID=? ORDER BY PAGE_ORD";
- PreparedStatement ps = conn.prepareStatement(sql);
- ps.setLong(1, channelId);
-
- ResultSet rs = ps.executeQuery();
-
- while (rs.next())
- {
- long msgId = rs.getLong(1);
- long pageOrd = rs.getLong(3);
-
- //log.info("Exists " + msgId + " with page ord " + pageOrd);
-
- msgIds.add(new Long(msgId));
- }
- rs.close();
- ps.close();
-
- conn.close();
-
- mgr.commit();
-
- if (txOld != null)
- {
- mgr.resume(txOld);
- }
-
- return msgIds;
- }
-
- protected List getPagedReferenceIds(long channelId) throws Exception
- {
- InitialContext ctx = new InitialContext();
-
- TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
- DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
-
- javax.transaction.Transaction txOld = mgr.suspend();
- mgr.begin();
-
- Connection conn = ds.getConnection();
- String sql = "SELECT MESSAGEID FROM JMS_MESSAGE_REFERENCE WHERE CHANNELID=? AND PAGE_ORD IS NOT NULL ORDER BY PAGE_ORD";
- PreparedStatement ps = conn.prepareStatement(sql);
- ps.setLong(1, channelId);
-
- ResultSet rs = ps.executeQuery();
-
- List msgIds = new ArrayList();
-
- while (rs.next())
- {
- long msgId = rs.getLong(1);
- msgIds.add(new Long(msgId));
- }
- rs.close();
- ps.close();
- conn.close();
-
- mgr.commit();
-
- if (txOld != null)
- {
- mgr.resume(txOld);
- }
-
- return msgIds;
- }
-
- protected List getMessageIds() throws Exception
- {
- InitialContext ctx = new InitialContext();
-
- TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
- DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
-
- javax.transaction.Transaction txOld = mgr.suspend();
- mgr.begin();
-
- Connection conn = ds.getConnection();
- String sql = "SELECT MESSAGEID FROM JMS_MESSAGE ORDER BY MESSAGEID";
- PreparedStatement ps = conn.prepareStatement(sql);
-
- ResultSet rs = ps.executeQuery();
-
- List msgIds = new ArrayList();
-
- while (rs.next())
- {
- long msgId = rs.getLong(1);
- msgIds.add(new Long(msgId));
- }
- rs.close();
- ps.close();
- conn.close();
-
- mgr.commit();
-
- if (txOld != null)
- {
- mgr.resume(txOld);
- }
-
- return msgIds;
- }
-
-}
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_2PCTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_2PCTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_2PCTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -30,6 +30,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_NTTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_NTTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_NTTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -29,6 +29,7 @@
import org.jboss.messaging.core.local.PagingFilteredQueue;
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_TTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_TTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_NP_TTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -30,6 +30,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_2PCTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_2PCTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_2PCTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -30,6 +30,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_NTTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_NTTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_NTTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -29,6 +29,7 @@
import org.jboss.messaging.core.local.PagingFilteredQueue;
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_TTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_TTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_P_TTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -30,6 +30,7 @@
import org.jboss.messaging.core.plugin.LockMap;
import org.jboss.messaging.core.tx.Transaction;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Modified: trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_ReloadTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_ReloadTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/SingleChannel_ReloadTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -32,6 +32,7 @@
import org.jboss.messaging.core.plugin.SimpleMessageStore;
import org.jboss.messaging.core.tx.TransactionRepository;
import org.jboss.test.messaging.util.CoreMessageFactory;
+import org.jboss.test.messaging.core.paging.base.PagingStateTestBase;
import EDU.oswego.cs.dl.util.concurrent.QueuedExecutor;
Added: trunk/tests/src/org/jboss/test/messaging/core/paging/base/PagingStateTestBase.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/core/paging/base/PagingStateTestBase.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/core/paging/base/PagingStateTestBase.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -0,0 +1,572 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.test.messaging.core.paging.base;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import javax.naming.InitialContext;
+import javax.sql.DataSource;
+import javax.transaction.TransactionManager;
+
+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.SimpleDelivery;
+import org.jboss.messaging.core.plugin.IdManager;
+import org.jboss.messaging.core.plugin.JDBCPersistenceManager;
+import org.jboss.messaging.core.plugin.SimpleMessageStore;
+import org.jboss.messaging.core.plugin.contract.PersistenceManager;
+import org.jboss.messaging.core.tx.Transaction;
+import org.jboss.messaging.core.tx.TransactionRepository;
+import org.jboss.messaging.core.tx.XidImpl;
+import org.jboss.test.messaging.MessagingTestCase;
+import org.jboss.test.messaging.tools.jmx.ServiceContainer;
+import org.jboss.tm.TransactionManagerService;
+import org.jboss.util.id.GUID;
+
+/**
+ *
+ * A PagingStateTestBase.
+ *
+ * @author <a href="tim.fox at jboss.com">Tim Fox</a>
+ * @version 1.1
+ *
+ * PagingStateTestBase.java,v 1.1 2006/03/22 10:23:35 timfox Exp
+ */
+public class PagingStateTestBase extends MessagingTestCase
+{
+ // Constants -----------------------------------------------------
+
+ // Static --------------------------------------------------------
+
+ // Attributes ----------------------------------------------------
+
+ protected ServiceContainer sc;
+ protected PersistenceManager pm;
+ protected SimpleMessageStore ms;
+ protected TransactionRepository tr;
+
+ // Constructors --------------------------------------------------
+
+ public PagingStateTestBase(String name)
+ {
+ super(name);
+ }
+
+ // Public --------------------------------------------------------
+
+ public void testEmpty()
+ {
+
+ }
+
+ public void setUp() throws Exception
+ {
+ super.setUp();
+
+ sc = new ServiceContainer("all,-remoting,-security");
+ sc.start();
+
+ pm =
+ new JDBCPersistenceManager(sc.getDataSource(), sc.getTransactionManager(), null,
+ true, true, true, 100);
+ pm.start();
+
+ tr = new TransactionRepository(pm, new IdManager("TRANSACTION_ID", 10, pm));
+ tr.start();
+
+ ms = new SimpleMessageStore();
+ ms.start();
+ }
+
+
+ public void tearDown() throws Exception
+ {
+ pm.stop();
+ tr.stop();
+ ms.stop();
+ sc.stop();
+
+ super.tearDown();
+ }
+
+ protected Transaction createXATx() throws Exception
+ {
+ XidImpl xid = new XidImpl(new GUID().toString().getBytes(), 345, new GUID().toString().getBytes());
+
+ return tr.createTransaction(xid);
+ }
+
+ protected void assertSameIds(List ids, MessageReference[] refs, int start, int end)
+ {
+ assertNotNull(ids);
+ assertEquals(ids.size(), end - start + 1);
+ Iterator iter = ids.iterator();
+ int i = start;
+ while (iter.hasNext())
+ {
+ Long id = (Long)iter.next();
+ assertEquals(refs[i].getMessageID(), id.longValue());
+ i++;
+ }
+ }
+
+ class ConsumingReceiver implements Receiver
+ {
+ int numToConsume;
+
+ 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, MessageReference ref, Transaction tx)
+ {
+ if (count >= numToConsume)
+ {
+ return null;
+ }
+
+ assertEquals(refs[consumeCount + count].getMessageID(), ref.getMessageID());
+
+ SimpleDelivery del = new SimpleDelivery(observer, ref);
+
+ dels[count] = del;
+
+ count++;
+
+ if (count == numToConsume)
+ {
+ notify();
+ }
+
+ 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, MessageReference ref, Transaction tx)
+ {
+ if (count == numToCancel)
+ {
+ return null;
+ }
+
+ SimpleDelivery del = new SimpleDelivery(observer, ref);
+
+ toCancel[count] = del;
+
+ count++;
+
+ if (count == numToCancel)
+ {
+ notify();
+ }
+
+ return del;
+
+ }
+
+ public synchronized SimpleDelivery[] getToCancel() throws Exception
+ {
+ // Wait for them all to arrive first
+
+ while (count < numToCancel)
+ {
+ wait(1000);
+
+ if (count < numToCancel)
+ {
+ PagingStateTestBase.fail();
+ return null;
+ }
+ }
+
+ 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
+ {
+ 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
+ {
+ 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);
+ }
+
+ 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);
+ }
+
+
+ protected List getReferenceIdsOrderedByOrd(long channelId) throws Exception
+ {
+ InitialContext ctx = new InitialContext();
+
+ TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
+ DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
+
+ javax.transaction.Transaction txOld = mgr.suspend();
+ mgr.begin();
+
+ Connection conn = ds.getConnection();
+
+ List msgIds = new ArrayList();
+
+ String sql = "SELECT MESSAGEID, ORD, PAGE_ORD FROM JMS_MESSAGE_REFERENCE WHERE CHANNELID=? ORDER BY ORD";
+ PreparedStatement ps = conn.prepareStatement(sql);
+ ps.setLong(1, channelId);
+
+ ResultSet rs = ps.executeQuery();
+
+ while (rs.next())
+ {
+ long msgId = rs.getLong(1);
+ long ord = rs.getLong(2);
+
+ msgIds.add(new Long(msgId));
+ }
+ rs.close();
+ ps.close();
+
+ conn.close();
+
+ mgr.commit();
+
+ if (txOld != null)
+ {
+ mgr.resume(txOld);
+ }
+
+ return msgIds;
+ }
+
+ protected List getReferenceIdsOrderedByPageOrd(long channelId) throws Exception
+ {
+ InitialContext ctx = new InitialContext();
+
+ TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
+ DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
+
+ javax.transaction.Transaction txOld = mgr.suspend();
+ mgr.begin();
+
+ Connection conn = ds.getConnection();
+
+ List msgIds = new ArrayList();
+
+ //log.info("channel id:" + channelId);
+
+ String sql = "SELECT MESSAGEID, ORD, PAGE_ORD FROM JMS_MESSAGE_REFERENCE WHERE CHANNELID=? ORDER BY PAGE_ORD";
+ PreparedStatement ps = conn.prepareStatement(sql);
+ ps.setLong(1, channelId);
+
+ ResultSet rs = ps.executeQuery();
+
+ while (rs.next())
+ {
+ long msgId = rs.getLong(1);
+ long pageOrd = rs.getLong(3);
+
+ //log.info("Exists " + msgId + " with page ord " + pageOrd);
+
+ msgIds.add(new Long(msgId));
+ }
+ rs.close();
+ ps.close();
+
+ conn.close();
+
+ mgr.commit();
+
+ if (txOld != null)
+ {
+ mgr.resume(txOld);
+ }
+
+ return msgIds;
+ }
+
+ protected List getPagedReferenceIds(long channelId) throws Exception
+ {
+ InitialContext ctx = new InitialContext();
+
+ TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
+ DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
+
+ javax.transaction.Transaction txOld = mgr.suspend();
+ mgr.begin();
+
+ Connection conn = ds.getConnection();
+ String sql = "SELECT MESSAGEID FROM JMS_MESSAGE_REFERENCE WHERE CHANNELID=? AND PAGE_ORD IS NOT NULL ORDER BY PAGE_ORD";
+ PreparedStatement ps = conn.prepareStatement(sql);
+ ps.setLong(1, channelId);
+
+ ResultSet rs = ps.executeQuery();
+
+ List msgIds = new ArrayList();
+
+ while (rs.next())
+ {
+ long msgId = rs.getLong(1);
+ msgIds.add(new Long(msgId));
+ }
+ rs.close();
+ ps.close();
+ conn.close();
+
+ mgr.commit();
+
+ if (txOld != null)
+ {
+ mgr.resume(txOld);
+ }
+
+ return msgIds;
+ }
+
+ protected List getMessageIds() throws Exception
+ {
+ InitialContext ctx = new InitialContext();
+
+ TransactionManager mgr = (TransactionManager)ctx.lookup(TransactionManagerService.JNDI_NAME);
+ DataSource ds = (DataSource)ctx.lookup("java:/DefaultDS");
+
+ javax.transaction.Transaction txOld = mgr.suspend();
+ mgr.begin();
+
+ Connection conn = ds.getConnection();
+ String sql = "SELECT MESSAGEID FROM JMS_MESSAGE ORDER BY MESSAGEID";
+ PreparedStatement ps = conn.prepareStatement(sql);
+
+ ResultSet rs = ps.executeQuery();
+
+ List msgIds = new ArrayList();
+
+ while (rs.next())
+ {
+ long msgId = rs.getLong(1);
+ msgIds.add(new Long(msgId));
+ }
+ rs.close();
+ ps.close();
+ conn.close();
+
+ mgr.commit();
+
+ if (txOld != null)
+ {
+ mgr.resume(txOld);
+ }
+
+ return msgIds;
+ }
+
+}
Modified: trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTest.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTest.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTest.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -21,6 +21,8 @@
*/
package org.jboss.test.messaging.jms.stress;
+import org.jboss.test.messaging.jms.stress.base.StressTestBase;
+
import javax.jms.Connection;
import javax.jms.DeliveryMode;
import javax.jms.MessageConsumer;
Deleted: trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTestBase.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTestBase.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/jms/stress/StressTestBase.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -1,151 +0,0 @@
-/*
- * JBoss, Home of Professional Open Source
- * Copyright 2005, JBoss Inc., and individual contributors as indicated
- * by the @authors tag. See the copyright.txt in the distribution for a
- * full listing of individual contributors.
- *
- * This is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as
- * published by the Free Software Foundation; either version 2.1 of
- * the License, or (at your option) any later version.
- *
- * This software is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this software; if not, write to the Free
- * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
- */
-package org.jboss.test.messaging.jms.stress;
-
-import javax.jms.ConnectionFactory;
-import javax.jms.Destination;
-import javax.jms.Topic;
-import javax.naming.InitialContext;
-
-import org.jboss.messaging.core.plugin.LockMap;
-import org.jboss.test.messaging.MessagingTestCase;
-import org.jboss.test.messaging.tools.ServerManagement;
-
-/**
- *
- * Base class for stress tests
- *
- * @author <a href="tim.fox at jboss.com">Tim Fox</a>
- * @version 1.1
- *
- * StressTestBase.java,v 1.1 2006/01/17 12:15:33 timfox Exp
- */
-public class StressTestBase extends MessagingTestCase
-{
- protected static final int NUM_PERSISTENT_MESSAGES = 4000;
-
- protected static final int NUM_NON_PERSISTENT_MESSAGES = 6000;
-
- protected static final int NUM_PERSISTENT_PRESEND = 2000;
-
- protected static final int NUM_NON_PERSISTENT_PRESEND = 3000;
-
- protected ConnectionFactory cf;
-
- protected Destination topic;
-
- protected Destination queue1;
- protected Destination queue2;
- protected Destination queue3;
- protected Destination queue4;
-
- protected Topic topic1;
- protected Topic topic2;
- protected Topic topic3;
- protected Topic topic4;
-
- public StressTestBase(String name)
- {
- super(name);
- }
-
- public void setUp() throws Exception
- {
- super.setUp();
-
- ServerManagement.start("all");
-
- //We test with small values for paging params to really stress it
-
- final int fullSize = 1000;
-
- final int pageSize = 100;
-
- final int downCacheSize = 100;
-
- ServerManagement.deployQueue("Queue1", fullSize, pageSize, downCacheSize);
- ServerManagement.deployQueue("Queue2", fullSize, pageSize, downCacheSize);
- ServerManagement.deployQueue("Queue3", fullSize, pageSize, downCacheSize);
- ServerManagement.deployQueue("Queue4", fullSize, pageSize, downCacheSize);
-
- ServerManagement.deployTopic("Topic1", fullSize, pageSize, downCacheSize);
- ServerManagement.deployTopic("Topic2", fullSize, pageSize, downCacheSize);
- ServerManagement.deployTopic("Topic3", fullSize, pageSize, downCacheSize);
- ServerManagement.deployTopic("Topic4", fullSize, pageSize, downCacheSize);
-
- InitialContext ic = new InitialContext(ServerManagement.getJNDIEnvironment());
- cf = (ConnectionFactory)ic.lookup("/ConnectionFactory");
-
- queue1 = (Destination)ic.lookup("/queue/Queue1");
- queue2 = (Destination)ic.lookup("/queue/Queue2");
- queue3 = (Destination)ic.lookup("/queue/Queue3");
- queue4 = (Destination)ic.lookup("/queue/Queue4");
-
- topic1 = (Topic)ic.lookup("/topic/Topic1");
- topic2 = (Topic)ic.lookup("/topic/Topic2");
- topic3 = (Topic)ic.lookup("/topic/Topic3");
- topic4 = (Topic)ic.lookup("/topic/Topic4");
- }
-
- public void tearDown() throws Exception
- {
- assertEquals(0, LockMap.instance.getSize());
-
- ServerManagement.undeployQueue("Queue1");
- ServerManagement.undeployQueue("Queue2");
- ServerManagement.undeployQueue("Queue3");
- ServerManagement.undeployQueue("Queue4");
-
- ServerManagement.undeployTopic("Topic1");
- ServerManagement.undeployTopic("Topic2");
- ServerManagement.undeployTopic("Topic3");
- ServerManagement.undeployTopic("Topic4");
-
- ServerManagement.stop();
-
- super.tearDown();
- }
-
- protected void runRunners(Runner[] runners) throws Exception
- {
- Thread[] threads = new Thread[runners.length];
- for (int i = 0; i < runners.length; i++)
- {
- threads[i] = new Thread(runners[i]);
- threads[i].start();
- }
-
- for (int i = 0; i < runners.length; i++)
- {
- threads[i].join();
- }
-
- for (int i = 0; i < runners.length; i++)
- {
- if (runners[i].isFailed())
- {
- fail("Runner " + i + " failed");
- log.error("runner failed");
- }
- }
- }
-}
Added: trunk/tests/src/org/jboss/test/messaging/jms/stress/base/StressTestBase.java
===================================================================
--- trunk/tests/src/org/jboss/test/messaging/jms/stress/base/StressTestBase.java 2006-09-28 02:01:27 UTC (rev 1370)
+++ trunk/tests/src/org/jboss/test/messaging/jms/stress/base/StressTestBase.java 2006-09-28 02:09:05 UTC (rev 1371)
@@ -0,0 +1,152 @@
+/*
+ * JBoss, Home of Professional Open Source
+ * Copyright 2005, JBoss Inc., and individual contributors as indicated
+ * by the @authors tag. See the copyright.txt in the distribution for a
+ * full listing of individual contributors.
+ *
+ * This is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as
+ * published by the Free Software Foundation; either version 2.1 of
+ * the License, or (at your option) any later version.
+ *
+ * This software is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this software; if not, write to the Free
+ * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
+ */
+package org.jboss.test.messaging.jms.stress.base;
+
+import javax.jms.ConnectionFactory;
+import javax.jms.Destination;
+import javax.jms.Topic;
+import javax.naming.InitialContext;
+
+import org.jboss.messaging.core.plugin.LockMap;
+import org.jboss.test.messaging.MessagingTestCase;
+import org.jboss.test.messaging.jms.stress.Runner;
+import org.jboss.test.messaging.tools.ServerManagement;
+
+/**
+ *
+ * Base class for stress tests
+ *
+ * @author <a href="tim.fox at jboss.com">Tim Fox</a>
+ * @version 1.1
+ *
+ * StressTestBase.java,v 1.1 2006/01/17 12:15:33 timfox Exp
+ */
+public class StressTestBase extends MessagingTestCase
+{
+ protected static final int NUM_PERSISTENT_MESSAGES = 4000;
+
+ protected static final int NUM_NON_PERSISTENT_MESSAGES = 6000;
+
+ protected static final int NUM_PERSISTENT_PRESEND = 2000;
+
+ protected static final int NUM_NON_PERSISTENT_PRESEND = 3000;
+
+ protected ConnectionFactory cf;
+
+ protected Destination topic;
+
+ protected Destination queue1;
+ protected Destination queue2;
+ protected Destination queue3;
+ protected Destination queue4;
+
+ protected Topic topic1;
+ protected Topic topic2;
+ protected Topic topic3;
+ protected Topic topic4;
+
+ public StressTestBase(String name)
+ {
+ super(name);
+ }
+
+ public void setUp() throws Exception
+ {
+ super.setUp();
+
+ ServerManagement.start("all");
+
+ //We test with small values for paging params to really stress it
+
+ final int fullSize = 1000;
+
+ final int pageSize = 100;
+
+ final int downCacheSize = 100;
+
+ ServerManagement.deployQueue("Queue1", fullSize, pageSize, downCacheSize);
+ ServerManagement.deployQueue("Queue2", fullSize, pageSize, downCacheSize);
+ ServerManagement.deployQueue("Queue3", fullSize, pageSize, downCacheSize);
+ ServerManagement.deployQueue("Queue4", fullSize, pageSize, downCacheSize);
+
+ ServerManagement.deployTopic("Topic1", fullSize, pageSize, downCacheSize);
+ ServerManagement.deployTopic("Topic2", fullSize, pageSize, downCacheSize);
+ ServerManagement.deployTopic("Topic3", fullSize, pageSize, downCacheSize);
+ ServerManagement.deployTopic("Topic4", fullSize, pageSize, downCacheSize);
+
+ InitialContext ic = new InitialContext(ServerManagement.getJNDIEnvironment());
+ cf = (ConnectionFactory)ic.lookup("/ConnectionFactory");
+
+ queue1 = (Destination)ic.lookup("/queue/Queue1");
+ queue2 = (Destination)ic.lookup("/queue/Queue2");
+ queue3 = (Destination)ic.lookup("/queue/Queue3");
+ queue4 = (Destination)ic.lookup("/queue/Queue4");
+
+ topic1 = (Topic)ic.lookup("/topic/Topic1");
+ topic2 = (Topic)ic.lookup("/topic/Topic2");
+ topic3 = (Topic)ic.lookup("/topic/Topic3");
+ topic4 = (Topic)ic.lookup("/topic/Topic4");
+ }
+
+ public void tearDown() throws Exception
+ {
+ assertEquals(0, LockMap.instance.getSize());
+
+ ServerManagement.undeployQueue("Queue1");
+ ServerManagement.undeployQueue("Queue2");
+ ServerManagement.undeployQueue("Queue3");
+ ServerManagement.undeployQueue("Queue4");
+
+ ServerManagement.undeployTopic("Topic1");
+ ServerManagement.undeployTopic("Topic2");
+ ServerManagement.undeployTopic("Topic3");
+ ServerManagement.undeployTopic("Topic4");
+
+ ServerManagement.stop();
+
+ super.tearDown();
+ }
+
+ protected void runRunners(Runner[] runners) throws Exception
+ {
+ Thread[] threads = new Thread[runners.length];
+ for (int i = 0; i < runners.length; i++)
+ {
+ threads[i] = new Thread(runners[i]);
+ threads[i].start();
+ }
+
+ for (int i = 0; i < runners.length; i++)
+ {
+ threads[i].join();
+ }
+
+ for (int i = 0; i < runners.length; i++)
+ {
+ if (runners[i].isFailed())
+ {
+ fail("Runner " + i + " failed");
+ log.error("runner failed");
+ }
+ }
+ }
+}
More information about the jboss-cvs-commits
mailing list