Java ClientConsumer.close方法代码示例

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
private void doTestBasicGrouping() throws Exception {
   ClientProducer clientProducer = clientSession.createProducer(qName);
   ClientConsumer consumer = clientSession.createConsumer(qName);
   ClientConsumer consumer2 = clientSession.createConsumer(qName);
   clientSession.start();

   SimpleString groupId = new SimpleString("grp1");
   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(clientSession, "m" + i);
      message.putStringProperty(Message.HDR_GROUP_ID, groupId);
      clientProducer.send(message);
   }

   CountDownLatch latch = new CountDownLatch(numMessages);
   DummyMessageHandler dummyMessageHandler = new DummyMessageHandler(latch, true);
   consumer.setMessageHandler(dummyMessageHandler);
   DummyMessageHandler dummyMessageHandler2 = new DummyMessageHandler(latch, true);
   consumer2.setMessageHandler(dummyMessageHandler2);
   Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
   Assert.assertEquals(100, dummyMessageHandler.list.size());
   Assert.assertEquals(0, dummyMessageHandler2.list.size());
   consumer.close();
   consumer2.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
private void doTestBasicGroupingUsingConnectionFactory() throws Exception {
   ClientProducer clientProducer = clientSession.createProducer(qName);
   ClientConsumer consumer = clientSession.createConsumer(qName);
   ClientConsumer consumer2 = clientSession.createConsumer(qName);
   clientSession.start();

   int numMessages = 100;
   for (int i = 0; i < numMessages; i++) {
      ClientMessage message = createTextMessage(clientSession, "m" + i);
      clientProducer.send(message);
   }
   CountDownLatch latch = new CountDownLatch(numMessages);
   DummyMessageHandler dummyMessageHandler = new DummyMessageHandler(latch, true);
   consumer.setMessageHandler(dummyMessageHandler);
   DummyMessageHandler dummyMessageHandler2 = new DummyMessageHandler(latch, true);
   consumer2.setMessageHandler(dummyMessageHandler2);
   Assert.assertTrue(latch.await(10, TimeUnit.SECONDS));
   Assert.assertEquals(100, dummyMessageHandler.list.size());
   Assert.assertEquals(0, dummyMessageHandler2.list.size());
   consumer.close();
   consumer2.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testNonDurableMessageOnDurableQueue() throws Exception {
   boolean durable = true;

   SimpleString address = RandomUtil.randomSimpleString();
   SimpleString queue = RandomUtil.randomSimpleString();

   session.createQueue(address, queue, durable);

   ClientProducer producer = session.createProducer(address);
   producer.send(session.createMessage(!durable));

   restart();

   session.start();
   ClientConsumer consumer = session.createConsumer(queue);
   Assert.assertNull(consumer.receiveImmediate());

   consumer.close();
   session.deleteQueue(queue);
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
/**
 * https://jira.jboss.org/jira/browse/HORNETQ-286
 *
 * the test checks that the temp queue is properly propagated to the cluster
 * (assuming we wait for the bindings)
 */
@Test
public void testSendToTempQueueFromAnotherClusterNode() throws Exception {
   setupCluster();

   startServers(0, 1);

   setupSessionFactory(0, isNetty());
   setupSessionFactory(1, isNetty());

   String tempAddress = "queues.tempaddress";
   String tempQueue = "tempqueue";
   // create temp queue on node #0
   ClientSession session = sfs[0].createSession(false, true, true);
   session.createTemporaryQueue(tempAddress, tempQueue);
   ClientConsumer consumer = session.createConsumer(tempQueue);

   // check the binding is created on node #1
   waitForBindings(1, tempAddress, 1, 1, false);

   // send to the temp address on node #1
   send(1, tempAddress, 10, false, null);

   session.start();

   // check consumer bound to node #0 receives from the temp queue
   for (int j = 0; j < 10; j++) {
      ClientMessage message = consumer.receive(5000);
      if (message == null) {
         Assert.assertNotNull("consumer did not receive message on temp queue " + j, message);
      }
      message.acknowledge();
   }

   consumer.close();
   session.deleteQueue(tempQueue);
   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Override
public void run() {
   ClientSessionFactory factory;
   ClientSession session;
   try {
      factory = locator.createSessionFactory();
      session = factory.createSession(false, false);
      session.start();

      int msgcount = 0;

      for (int i = 0; i < 100 && running; i++) {
         SimpleString queueName = ADDRESS.concat("_" + sequence.incrementAndGet());
         session.createQueue(ADDRESS, queueName, true);
         ClientConsumer consumer = session.createConsumer(queueName);
         while (running) {
            ClientMessage msg = consumer.receive(5000);
            if (msg == null) {
               break;
            }
            if (msgcount++ == 500) {
               msgcount = 0;
               break;
            }
         }
         consumer.close();
         session.commit();
         session.deleteQueue(queueName);
         System.out.println("Deleting " + queueName);
      }
      session.close();
   } catch (Throwable e) {
      this.ex = e;
      e.printStackTrace();
      running = false;
   }
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testLargeWildcardRouting() throws Exception {
   SimpleString addressAB = new SimpleString("a.b.c.d.e.f.g.h.i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z");
   SimpleString addressAC = new SimpleString("a.c");
   SimpleString address = new SimpleString("a.#");
   SimpleString queueName1 = new SimpleString("Q1");
   SimpleString queueName2 = new SimpleString("Q2");
   SimpleString queueName = new SimpleString("Q");
   clientSession.createQueue(addressAB, queueName1, null, false);
   clientSession.createQueue(addressAC, queueName2, null, false);
   clientSession.createQueue(address, queueName, null, false);
   Assert.assertEquals(2, server.getPostOffice().getBindingsForAddress(addressAB).getBindings().size());
   Assert.assertEquals(2, server.getPostOffice().getBindingsForAddress(addressAC).getBindings().size());
   Assert.assertEquals(1, server.getPostOffice().getBindingsForAddress(address).getBindings().size());
   ClientProducer producer = clientSession.createProducer(addressAB);
   ClientProducer producer2 = clientSession.createProducer(addressAC);
   ClientConsumer clientConsumer = clientSession.createConsumer(queueName);
   clientSession.start();
   producer.send(createTextMessage(clientSession, "m1"));
   producer2.send(createTextMessage(clientSession, "m2"));
   ClientMessage m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals("m1", m.getBodyBuffer().readString());
   m.acknowledge();
   m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals("m2", m.getBodyBuffer().readString());
   m.acknowledge();
   m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();
   clientSession.deleteQueue(queueName);
   Assert.assertEquals(1, server.getPostOffice().getBindingsForAddress(addressAB).getBindings().size());
   Assert.assertEquals(1, server.getPostOffice().getBindingsForAddress(addressAC).getBindings().size());
   Assert.assertEquals(0, server.getPostOffice().getBindingsForAddress(address).getBindings().size());
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testExpireWithOverridenSublevelAddressSettings() throws Exception {
   SimpleString address = new SimpleString("prefix.address");
   SimpleString queue = RandomUtil.randomSimpleString();
   SimpleString defaultExpiryAddress = RandomUtil.randomSimpleString();
   SimpleString defaultExpiryQueue = RandomUtil.randomSimpleString();
   SimpleString specificExpiryAddress = RandomUtil.randomSimpleString();
   SimpleString specificExpiryQueue = RandomUtil.randomSimpleString();

   AddressSettings defaultAddressSettings = new AddressSettings().setExpiryAddress(defaultExpiryAddress);
   server.getAddressSettingsRepository().addMatch("prefix.*", defaultAddressSettings);
   AddressSettings specificAddressSettings = new AddressSettings().setExpiryAddress(specificExpiryAddress);
   server.getAddressSettingsRepository().addMatch("prefix.address", specificAddressSettings);

   clientSession.createQueue(address, queue, false);
   clientSession.createQueue(defaultExpiryAddress, defaultExpiryQueue, false);
   clientSession.createQueue(specificExpiryAddress, specificExpiryQueue, false);

   ClientProducer producer = clientSession.createProducer(address);
   ClientMessage clientMessage = createTextMessage(clientSession, "heyho!");
   clientMessage.setExpiration(System.currentTimeMillis());
   producer.send(clientMessage);

   clientSession.start();
   ClientConsumer clientConsumer = clientSession.createConsumer(queue);
   ClientMessage m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();

   clientConsumer = clientSession.createConsumer(defaultExpiryQueue);
   m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();

   clientConsumer = clientSession.createConsumer(specificExpiryQueue);
   m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   m.acknowledge();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testBasicSend() throws Exception {
   SimpleString ea = new SimpleString("EA");
   SimpleString adSend = new SimpleString("a1");
   SimpleString qName = new SimpleString("q1");
   SimpleString eq = new SimpleString("EA1");
   AddressSettings addressSettings = new AddressSettings().setExpiryAddress(ea);
   server.getAddressSettingsRepository().addMatch("#", addressSettings);
   clientSession.createQueue(ea, eq, null, false);
   clientSession.createQueue(adSend, qName, null, false);

   ClientProducer producer = clientSession.createProducer(adSend);
   ClientMessage clientMessage = createTextMessage(clientSession, "heyho!");
   clientMessage.setExpiration(System.currentTimeMillis());
   producer.send(clientMessage);

   clientSession.start();
   ClientConsumer clientConsumer = clientSession.createConsumer(qName);
   ClientMessage m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();
   clientConsumer = clientSession.createConsumer(eq);
   m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   Assert.assertEquals(qName.toString(), m.getStringProperty(Message.HDR_ORIGINAL_QUEUE));
   Assert.assertEquals(adSend.toString(), m.getStringProperty(Message.HDR_ORIGINAL_ADDRESS));
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   m.acknowledge();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testBasicSendToMultipleQueues() throws Exception {
   SimpleString dla = new SimpleString("DLA");
   SimpleString qName = new SimpleString("q1");
   AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1).setDeadLetterAddress(dla);
   server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
   SimpleString dlq = new SimpleString("DLQ1");
   SimpleString dlq2 = new SimpleString("DLQ2");
   clientSession.createQueue(dla, dlq, null, false);
   clientSession.createQueue(dla, dlq2, null, false);
   clientSession.createQueue(qName, qName, null, false);
   ClientProducer producer = clientSession.createProducer(qName);
   producer.send(createTextMessage(clientSession, "heyho!"));
   clientSession.start();
   ClientConsumer clientConsumer = clientSession.createConsumer(qName);
   ClientMessage m = clientConsumer.receive(500);
   m.acknowledge();
   Assert.assertNotNull(m);
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   // force a cancel
   clientSession.rollback();
   m = clientConsumer.receiveImmediate();
   Assert.assertNull(m);
   clientConsumer.close();
   clientConsumer = clientSession.createConsumer(dlq);
   m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   m.acknowledge();
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   clientConsumer.close();
   clientConsumer = clientSession.createConsumer(dlq2);
   m = clientConsumer.receive(500);
   Assert.assertNotNull(m);
   m.acknowledge();
   Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
   clientConsumer.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testTotalConsumerCount() throws Exception {
   String random1 = RandomUtil.randomString();
   String random2 = RandomUtil.randomString();

   ActiveMQServerControl serverControl = createManagementControl();
   QueueControl queueControl1 = ManagementControlHelper.createQueueControl(SimpleString.toSimpleString(random1), SimpleString.toSimpleString(random1), RoutingType.ANYCAST, mbeanServer);
   QueueControl queueControl2 = ManagementControlHelper.createQueueControl(SimpleString.toSimpleString(random2), SimpleString.toSimpleString(random2), RoutingType.ANYCAST, mbeanServer);

   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory csf = createSessionFactory(locator);
   ClientSession session = csf.createSession();

   session.createQueue(random1, RoutingType.ANYCAST, random1);
   session.createQueue(random2, RoutingType.ANYCAST, random2);

   ClientConsumer consumer1 = session.createConsumer(random1);
   ClientConsumer consumer2 = session.createConsumer(random2);

   assertEquals(usingCore() ? 3 : 2, serverControl.getTotalConsumerCount());
   assertEquals(1, queueControl1.getConsumerCount());
   assertEquals(1, queueControl2.getConsumerCount());

   consumer1.close();
   consumer2.close();

   session.deleteQueue(random1);
   session.deleteQueue(random2);

   session.close();

   locator.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testPagedMessageDeliveredMultipleConsumersCorrectly() throws Exception {
   AddressSettings qs = new AddressSettings().setRedeliveryDelay(5000L);
   server.getAddressSettingsRepository().addMatch(atestq.toString(), qs);
   // then we create a client as normal
   ClientSessionFactory sessionFactory = createSessionFactory(locator);
   ClientSession session = sessionFactory.createSession(false, true, false);
   session.createQueue(atestq, atestq, null, true);
   session.createQueue(atestq, atestq2, null, true);
   ClientProducer producer = session.createProducer(atestq);
   ClientMessage message = createDurableMessage(session, "m1");
   producer.send(message);

   producer.close();

   ClientConsumer consumer = session.createConsumer(atestq);
   ClientConsumer consumer2 = session.createConsumer(atestq2);

   session.start();
   ClientMessage message3 = consumer.receive(1000);
   message3.acknowledge();
   ClientMessage message2 = consumer2.receive(1000);
   message2.acknowledge();
   Assert.assertEquals("m1", message3.getBodyBuffer().readString());
   Assert.assertEquals("m1", message2.getBodyBuffer().readString());
   long time = System.currentTimeMillis();
   // force redelivery
   consumer.close();
   consumer2.close();
   // this will make it redelivery-delay
   session.rollback();
   consumer = session.createConsumer(atestq);
   consumer2 = session.createConsumer(atestq2);
   message3 = consumer.receive(5250);
   message2 = consumer2.receive(1000);
   time += 5000;
   Assert.assertTrue(System.currentTimeMillis() >= time);
   Assert.assertEquals("m1", message3.getBodyBuffer().readString());
   Assert.assertEquals("m1", message2.getBodyBuffer().readString());
   message2.acknowledge();
   message3.acknowledge();

   // Make sure no more messages
   consumer.close();
   consumer2.close();
   consumer = session.createConsumer(atestq);
   Assert.assertNull(consumer.receiveImmediate());

   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testCreateAndDestroyDivert() throws Exception {
   String address = RandomUtil.randomString();
   String name = RandomUtil.randomString();
   String routingName = RandomUtil.randomString();
   String forwardingAddress = RandomUtil.randomString();

   ActiveMQServerControl serverControl = createManagementControl();

   checkNoResource(ObjectNameBuilder.DEFAULT.getDivertObjectName(name, address));
   assertEquals(0, serverControl.getDivertNames().length);

   serverControl.createDivert(name.toString(), routingName, address, forwardingAddress, true, null, null);

   checkResource(ObjectNameBuilder.DEFAULT.getDivertObjectName(name, address));
   DivertControl divertControl = ManagementControlHelper.createDivertControl(name.toString(), address, mbeanServer);
   assertEquals(name.toString(), divertControl.getUniqueName());
   assertEquals(address, divertControl.getAddress());
   assertEquals(forwardingAddress, divertControl.getForwardingAddress());
   assertEquals(routingName, divertControl.getRoutingName());
   assertTrue(divertControl.isExclusive());
   assertNull(divertControl.getFilter());
   assertNull(divertControl.getTransformerClassName());
   String[] divertNames = serverControl.getDivertNames();
   assertEquals(1, divertNames.length);
   assertEquals(name, divertNames[0]);

   // check that a message sent to the address is diverted exclusively
   ServerLocator locator = createInVMNonHALocator();

   ClientSessionFactory csf = createSessionFactory(locator);
   ClientSession session = csf.createSession();

   String divertQueue = RandomUtil.randomString();
   String queue = RandomUtil.randomString();
   session.createQueue(forwardingAddress, RoutingType.ANYCAST, divertQueue);
   session.createQueue(address, RoutingType.ANYCAST, queue);

   ClientProducer producer = session.createProducer(address);
   ClientMessage message = session.createMessage(false);
   String text = RandomUtil.randomString();
   message.putStringProperty("prop", text);
   producer.send(message);

   ClientConsumer consumer = session.createConsumer(queue);
   ClientConsumer divertedConsumer = session.createConsumer(divertQueue);

   session.start();

   assertNull(consumer.receiveImmediate());
   message = divertedConsumer.receive(5000);
   assertNotNull(message);
   assertEquals(text, message.getStringProperty("prop"));

   serverControl.destroyDivert(name.toString());

   checkNoResource(ObjectNameBuilder.DEFAULT.getDivertObjectName(name, address));
   assertEquals(0, serverControl.getDivertNames().length);

   // check that a message is no longer diverted
   message = session.createMessage(false);
   String text2 = RandomUtil.randomString();
   message.putStringProperty("prop", text2);
   producer.send(message);

   assertNull(divertedConsumer.receiveImmediate());
   message = consumer.receive(5000);
   assertNotNull(message);
   assertEquals(text2, message.getStringProperty("prop"));

   consumer.close();
   divertedConsumer.close();
   session.deleteQueue(queue);
   session.deleteQueue(divertQueue);
   session.close();

   locator.close();

}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
public void testScheduledAndNormalMessagesDeliveredCorrectly(final boolean recover) throws Exception {

      ClientSessionFactory sessionFactory = createSessionFactory(locator);
      ClientSession session = sessionFactory.createSession(false, true, false);
      session.createQueue(atestq, atestq, null, true);
      ClientProducer producer = session.createProducer(atestq);
      ClientMessage m1 = createDurableMessage(session, "m1");
      ClientMessage m2 = createDurableMessage(session, "m2");
      ClientMessage m3 = createDurableMessage(session, "m3");
      ClientMessage m4 = createDurableMessage(session, "m4");
      ClientMessage m5 = createDurableMessage(session, "m5");
      long time = System.currentTimeMillis();
      time += 10000;
      m1.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m1);
      producer.send(m2);
      time += 1000;
      m3.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m3);
      producer.send(m4);
      time += 1000;
      m5.putLongProperty(Message.HDR_SCHEDULED_DELIVERY_TIME, time);
      producer.send(m5);
      time -= 2000;
      ClientConsumer consumer = null;
      if (recover) {
         producer.close();
         session.close();
         server.stop();
         server = null;
         server = createServer(true, configuration);
         server.start();

         sessionFactory = createSessionFactory(locator);

         session = sessionFactory.createSession(false, true, true);
      }

      consumer = session.createConsumer(atestq);
      session.start();

      ClientMessage message = consumer.receive(1000);
      Assert.assertEquals("m2", message.getBodyBuffer().readString());
      message.acknowledge();
      message = consumer.receive(1000);
      Assert.assertEquals("m4", message.getBodyBuffer().readString());
      message.acknowledge();
      message = consumer.receive(10250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m1", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m3", message.getBodyBuffer().readString());
      message.acknowledge();
      time += 1000;
      message = consumer.receive(1250);
      Assert.assertTrue(System.currentTimeMillis() >= time);
      Assert.assertEquals("m5", message.getBodyBuffer().readString());
      message.acknowledge();

      // Make sure no more messages
      consumer.close();
      consumer = session.createConsumer(atestq);
      Assert.assertNull(consumer.receiveImmediate());

      session.close();
   }
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testSendRegularAfterCompression() throws Exception {
   ActiveMQServer server = createServer(true, isNetty());
   server.start();

   ClientSessionFactory sf = createSessionFactory(locator);

   ClientSession session = addClientSession(sf.createSession(false, true, true));

   session.createTemporaryQueue(ADDRESS, ADDRESS);

   ClientProducer producer = session.createProducer(ADDRESS);

   int minLargeSize = locator.getMinLargeMessageSize();

   TestLargeMessageInputStream input = new TestLargeMessageInputStream(minLargeSize);
   adjustLargeCompression(true, input, 1024);

   int num = 1;
   for (int i = 0; i < num; i++) {
      ClientMessage clientFile = session.createMessage(true);
      clientFile.setBodyInputStream(input.clone());

      producer.send(clientFile);
   }

   session.start();

   //no file should be in the dir as we send it as regular
   validateNoFilesOnLargeDir();

   ClientConsumer consumer = session.createConsumer(ADDRESS);
   for (int j = 0; j < num; j++) {
      ClientMessage msg1 = consumer.receive(1000);
      Assert.assertNotNull(msg1);

      for (int i = 0; i < input.getSize(); i++) {
         byte b = msg1.getBodyBuffer().readByte();
         Assert.assertEquals("incorrect char ", input.getChar(i), b);
      }
      msg1.acknowledge();
   }

   session.commit();
   consumer.close();

   session.close();
}
 

import org.apache.activemq.artemis.api.core.client.ClientConsumer; //导入方法依赖的package包/类
@Test
public void testTotalMessagesAcknowledged() throws Exception {
   String random1 = RandomUtil.randomString();
   String random2 = RandomUtil.randomString();

   ActiveMQServerControl serverControl = createManagementControl();

   ServerLocator locator = createInVMNonHALocator();
   ClientSessionFactory csf = createSessionFactory(locator);
   ClientSession session = csf.createSession();

   session.createQueue(random1, RoutingType.ANYCAST, random1);
   session.createQueue(random2, RoutingType.ANYCAST, random2);

   ClientProducer producer1 = session.createProducer(random1);
   ClientProducer producer2 = session.createProducer(random2);
   ClientMessage message = session.createMessage(false);
   producer1.send(message);
   producer2.send(message);

   session.commit();

   ClientConsumer consumer1 = session.createConsumer(random1);
   ClientConsumer consumer2 = session.createConsumer(random2);

   session.start();

   assertNotNull(consumer1.receive().acknowledge());
   assertNotNull(consumer2.receive().acknowledge());

   session.commit();

   assertEquals(2, serverControl.getTotalMessagesAcknowledged());
   assertEquals(0, serverControl.getTotalMessageCount());

   consumer1.close();
   consumer2.close();

   session.deleteQueue(random1);
   session.deleteQueue(random2);

   session.close();

   locator.close();
}