org.apache.activemq.artemis.api.core.client.ClientConsumer

Here are the examples of the java api class org.apache.activemq.artemis.api.core.client.ClientConsumer taken from open source projects.

1. MessageGroupingTest#doTestBasicGrouping()

Project: activemq-artemis
File: MessageGroupingTest.java
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();
}

2. MessageGroupingConnectionFactoryTest#doTestBasicGroupingUsingConnectionFactory()

Project: activemq-artemis
File: MessageGroupingConnectionFactoryTest.java
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();
}

3. ConsumerTest#testClearListener()

Project: activemq-artemis
File: ConsumerTest.java
@Test
public void testClearListener() throws Exception {
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    session.createQueue(QUEUE, QUEUE, null, false);
    ClientConsumer consumer = session.createConsumer(QUEUE);
    consumer.setMessageHandler(new MessageHandler() {

        @Override
        public void onMessage(final ClientMessage msg) {
        }
    });
    consumer.setMessageHandler(null);
    consumer.receiveImmediate();
    session.close();
}

4. ReceiveTest#testReceiveThrowsExceptionWhenHandlerSet()

Project: activemq-artemis
File: ReceiveTest.java
@Test
public void testReceiveThrowsExceptionWhenHandlerSet() throws Exception {
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession session = cf.createSession(false, true, true);
    session.createQueue(addressA, queueA, false);
    ClientConsumer cc = session.createConsumer(queueA);
    session.start();
    cc.setMessageHandler(new MessageHandler() {

        @Override
        public void onMessage(final ClientMessage message) {
        }
    });
    try {
        cc.receive();
        Assert.fail("should throw exception");
    } catch (ActiveMQIllegalStateException ise) {
    } catch (ActiveMQException e) {
        Assert.fail("Invalid Exception type:" + e.getType());
    }
    session.close();
}

5. ReceiveTest#testReceiveTimesoutCorrectly()

Project: activemq-artemis
File: ReceiveTest.java
@Test
public void testReceiveTimesoutCorrectly() throws Exception {
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession session = cf.createSession(false, true, true);
    session.createQueue(addressA, queueA, false);
    ClientConsumer cc = session.createConsumer(queueA);
    session.start();
    long time = System.currentTimeMillis();
    cc.receive(1000);
    Assert.assertTrue(System.currentTimeMillis() - time >= 1000);
    session.close();
}

6. MessageExpirationTest#testMessageExpiredWithoutExpiryAddress()

Project: activemq-artemis
File: MessageExpirationTest.java
@Test
public void testMessageExpiredWithoutExpiryAddress() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    session.createQueue(address, queue, false);
    ClientProducer producer = session.createProducer(address);
    ClientMessage message = session.createMessage(false);
    message.setExpiration(System.currentTimeMillis() + MessageExpirationTest.EXPIRATION);
    producer.send(message);
    Thread.sleep(MessageExpirationTest.EXPIRATION * 2);
    session.start();
    ClientConsumer consumer = session.createConsumer(queue);
    ClientMessage message2 = consumer.receiveImmediate();
    Assert.assertNull(message2);
    consumer.close();
    session.deleteQueue(queue);
}

7. MessageDurabilityTest#testDurableMessageOnDurableQueue()

Project: activemq-artemis
File: MessageDurabilityTest.java
@Test
public void testDurableMessageOnDurableQueue() 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.assertNotNull(consumer.receive(500));
    consumer.close();
    session.deleteQueue(queue);
}

8. MessageDurabilityTest#testNonDurableMessageOnDurableQueue()

Project: activemq-artemis
File: MessageDurabilityTest.java
@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);
}

9. PagingReceiveTest#receiveMessage()

Project: activemq-artemis
File: PagingReceiveTest.java
private ClientMessage receiveMessage() throws Exception {
    final ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(null, null, false, true, true, false, 0);
    session.start();
    ClientConsumer consumer = session.createConsumer(ADDRESS);
    ClientMessage message = consumer.receive(1000);
    session.commit();
    if (message != null) {
        message.acknowledge();
    }
    consumer.close();
    session.close();
    return message;
}

10. QueueControlTest#testGetDeliveringCount()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testGetDeliveringCount() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    session.createQueue(address, queue, null, false);
    ClientProducer producer = session.createProducer(address);
    producer.send(session.createMessage(false));
    QueueControl queueControl = createManagementControl(address, queue);
    Assert.assertEquals(0, queueControl.getDeliveringCount());
    ClientConsumer consumer = session.createConsumer(queue);
    ClientMessage message = consumer.receive(500);
    Assert.assertNotNull(message);
    Assert.assertEquals(1, queueControl.getDeliveringCount());
    message.acknowledge();
    session.commit();
    Assert.assertEquals(0, queueControl.getDeliveringCount());
    consumer.close();
    session.deleteQueue(queue);
}

11. QueueControlTest#testGetConsumerCount()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testGetConsumerCount() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    session.createQueue(address, queue, null, false);
    QueueControl queueControl = createManagementControl(address, queue);
    Assert.assertEquals(0, queueControl.getConsumerCount());
    ClientConsumer consumer = session.createConsumer(queue);
    Assert.assertEquals(1, queueControl.getConsumerCount());
    consumer.close();
    Assert.assertEquals(0, queueControl.getConsumerCount());
    session.deleteQueue(queue);
}

12. LargeMessageTestBase#readMessage()

Project: activemq-artemis
File: LargeMessageTestBase.java
/**
    * @param session
    * @param queueToRead
    * @param numberOfBytes
    * @throws ActiveMQException
    * @throws IOException
    */
protected void readMessage(final ClientSession session, final SimpleString queueToRead, final int numberOfBytes) throws ActiveMQException, IOException {
    session.start();
    ClientConsumer consumer = session.createConsumer(queueToRead);
    ClientMessage clientMessage = consumer.receive(5000);
    Assert.assertNotNull(clientMessage);
    clientMessage.acknowledge();
    session.commit();
    consumer.close();
}

13. LVQTest#testFirstMessageReceivedAndCancelled()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testFirstMessageReceivedAndCancelled() throws Exception {
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    SimpleString rh = new SimpleString("SMID1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    ClientMessage m2 = createTextMessage(clientSession, "m2");
    m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    producer.send(m1);
    clientSession.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
    producer.send(m2);
    consumer.close();
    consumer = clientSession.createConsumer(qName1);
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    Assert.assertEquals("m2", m.getBodyBuffer().readString());
    m.acknowledge();
    m = consumer.receiveImmediate();
    Assert.assertNull(m);
}

14. ExpiryRunnerTest#testExpireConsumeHalf()

Project: activemq-artemis
File: ExpiryRunnerTest.java
@Test
public void testExpireConsumeHalf() throws Exception {
    ClientProducer producer = clientSession.createProducer(qName);
    int numMessages = 100;
    long expiration = System.currentTimeMillis() + 1000;
    for (int i = 0; i < numMessages; i++) {
        ClientMessage m = createTextMessage(clientSession, "m" + i);
        m.setExpiration(expiration);
        producer.send(m);
    }
    ClientConsumer consumer = clientSession.createConsumer(qName);
    clientSession.start();
    for (int i = 0; i < numMessages / 2; i++) {
        ClientMessage cm = consumer.receive(500);
        Assert.assertNotNull("message not received " + i, cm);
        cm.acknowledge();
        Assert.assertEquals("m" + i, cm.getBodyBuffer().readString());
    }
    consumer.close();
    Thread.sleep(2100);
    Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(qName).getBindable()).getMessageCount());
    Assert.assertEquals(0, ((Queue) server.getPostOffice().getBinding(qName).getBindable()).getDeliveringCount());
}

15. TemporaryQueueTest#testConsumeFromTemporaryQueue()

Project: activemq-artemis
File: TemporaryQueueTest.java
// Attributes ----------------------------------------------------
// Static --------------------------------------------------------
// Constructors --------------------------------------------------
// Public --------------------------------------------------------
@Test
public void testConsumeFromTemporaryQueue() throws Exception {
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString address = RandomUtil.randomSimpleString();
    session.createTemporaryQueue(address, queue);
    ClientProducer producer = session.createProducer(address);
    ClientMessage msg = session.createMessage(false);
    producer.send(msg);
    session.start();
    ClientConsumer consumer = session.createConsumer(queue);
    ClientMessage message = consumer.receive(500);
    assertNotNull(message);
    message.acknowledge();
    consumer.close();
    session.deleteQueue(queue);
    session.close();
}

16. SessionTest#testClose()

Project: activemq-artemis
File: SessionTest.java
@Test
public void testClose() throws Exception {
    cf = createSessionFactory(locator);
    ClientSession clientSession = cf.createSession(false, true, true);
    clientSession.createQueue(queueName, queueName, false);
    ClientProducer p = clientSession.createProducer();
    ClientProducer p1 = clientSession.createProducer(queueName);
    ClientConsumer c = clientSession.createConsumer(queueName);
    ClientConsumer c1 = clientSession.createConsumer(queueName);
    clientSession.close();
    Assert.assertTrue(clientSession.isClosed());
    Assert.assertTrue(p.isClosed());
    Assert.assertTrue(p1.isClosed());
    Assert.assertTrue(c.isClosed());
    Assert.assertTrue(c1.isClosed());
}

17. ExpiryAddressTest#testBasicSendToNoQueue()

Project: activemq-artemis
File: ExpiryAddressTest.java
@Test
public void testBasicSendToNoQueue() throws Exception {
    SimpleString ea = new SimpleString("EA");
    SimpleString qName = new SimpleString("q1");
    SimpleString eq = new SimpleString("EQ1");
    SimpleString eq2 = new SimpleString("EQ2");
    clientSession.createQueue(ea, eq, null, false);
    clientSession.createQueue(ea, eq2, null, false);
    clientSession.createQueue(qName, qName, null, false);
    ClientProducer producer = clientSession.createProducer(qName);
    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);
    clientConsumer.close();
}

18. DurableQueueTest#testConsumeFromDurableQueue()

Project: activemq-artemis
File: DurableQueueTest.java
// Static --------------------------------------------------------
// Constructors --------------------------------------------------
// Public --------------------------------------------------------
@Test
public void testConsumeFromDurableQueue() throws Exception {
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString address = RandomUtil.randomSimpleString();
    session.createQueue(address, queue, true);
    ClientProducer producer = session.createProducer(address);
    producer.send(session.createMessage(false));
    session.start();
    ClientConsumer consumer = session.createConsumer(queue);
    ClientMessage message = consumer.receive(500);
    Assert.assertNotNull(message);
    message.acknowledge();
    consumer.close();
    session.deleteQueue(queue);
}

19. DeadLetterAddressTest#testBasicSendToNoQueue()

Project: activemq-artemis
File: DeadLetterAddressTest.java
@Test
public void testBasicSendToNoQueue() throws Exception {
    SimpleString qName = new SimpleString("q1");
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1);
    server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
    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();
}

20. DeadLetterAddressTest#testReceiveWithListeners()

Project: activemq-artemis
File: DeadLetterAddressTest.java
@Test
public void testReceiveWithListeners() throws Exception {
    SimpleString dla = new SimpleString("DLA");
    SimpleString qName = new SimpleString("q1");
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(2).setDeadLetterAddress(dla);
    server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
    SimpleString dlq = new SimpleString("DLQ1");
    clientSession.createQueue(dla, dlq, null, false);
    clientSession.createQueue(qName, qName, null, false);
    ClientProducer producer = clientSession.createProducer(qName);
    producer.send(createTextMessage(clientSession, "heyho!"));
    ClientConsumer clientConsumer = clientSession.createConsumer(qName);
    final CountDownLatch latch = new CountDownLatch(2);
    TestHandler handler = new TestHandler(latch, clientSession);
    clientConsumer.setMessageHandler(handler);
    clientSession.start();
    assertTrue(latch.await(5, TimeUnit.SECONDS));
    assertEquals(handler.count, 2);
    clientConsumer = clientSession.createConsumer(dlq);
    Message m = clientConsumer.receive(5000);
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
}

21. DeadLetterAddressTest#testBasicSendWithDLAButNoBinding()

Project: activemq-artemis
File: DeadLetterAddressTest.java
// HORNETQ- 1084
@Test
public void testBasicSendWithDLAButNoBinding() 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");
    //clientSession.createQueue(dla, dlq, 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();
    Queue q = (Queue) server.getPostOffice().getBinding(qName).getBindable();
    Assert.assertEquals(0, q.getDeliveringCount());
}

22. NIOMultiThreadCompactorStressTest#addBogusData()

Project: activemq-artemis
File: NIOMultiThreadCompactorStressTest.java
/**
    * @throws ActiveMQException
    */
private void addBogusData(final int nmessages, final String queue) throws ActiveMQException {
    ClientSession session = sf.createSession(false, false);
    try {
        session.createQueue(queue, queue, true);
    } catch (Exception ignored) {
    }
    ClientProducer prod = session.createProducer(queue);
    for (int i = 0; i < nmessages; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.getBodyBuffer().writeBytes(new byte[1024]);
        prod.send(msg);
    }
    session.commit();
    session.start();
    ClientConsumer cons = session.createConsumer(queue);
    Assert.assertNotNull(cons.receive(1000));
    session.rollback();
    session.close();
}

23. NIOMultiThreadCompactorStressTest#drainQueue()

Project: activemq-artemis
File: NIOMultiThreadCompactorStressTest.java
/**
    * @param numberOfMessagesExpected
    * @param queue
    * @throws ActiveMQException
    */
private void drainQueue(final int numberOfMessagesExpected, final SimpleString queue) throws ActiveMQException {
    ClientSession sess = sf.createSession(true, true);
    ClientConsumer consumer = sess.createConsumer(queue);
    sess.start();
    for (int i = 0; i < numberOfMessagesExpected; i++) {
        ClientMessage msg = consumer.receive(5000);
        Assert.assertNotNull(msg);
        if (i % 100 == 0) {
        // System.out.println("Received #" + i + "  on thread after start");
        }
        msg.acknowledge();
    }
    Assert.assertNull(consumer.receiveImmediate());
    sess.close();
}

24. BasicXaTest#testSendWithoutXID()

Project: activemq-artemis
File: BasicXaTest.java
@Test
public void testSendWithoutXID() throws Exception {
    // Since both resources have same RM, TM will probably use 1PC optimization
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory factory = createSessionFactory(locator);
    ClientSession session = addClientSession(factory.createSession(true, false, false));
    session.createQueue("Test", "Test");
    ClientProducer prod = session.createProducer("Test");
    prod.send(session.createMessage(true));
    session.start();
    ClientConsumer cons = session.createConsumer("Test");
    assertNotNull("Send went through an invalid XA Session", cons.receiveImmediate());
}

25. LVQTest#testRemoveMessageThroughManagement()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testRemoveMessageThroughManagement() throws Exception {
    Queue queue = server.locateQueue(qName1);
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    SimpleString rh = new SimpleString("SMID1");
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    m1.setDurable(true);
    producer.send(m1);
    queue.deleteAllReferences();
    producer.send(m1);
    clientSession.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
    assertEquals(0, queue.getDeliveringCount());
}

26. LVQTest#testSingleTXRollback()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testSingleTXRollback() throws Exception {
    ClientProducer producer = clientSessionTxReceives.createProducer(address);
    ClientConsumer consumer = clientSessionTxReceives.createConsumer(qName1);
    SimpleString messageId1 = new SimpleString("SMID1");
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, messageId1);
    producer.send(m1);
    clientSessionTxReceives.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    clientSessionTxReceives.rollback();
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
    Assert.assertNull(consumer.receiveImmediate());
}

27. LVQTest#testSimpleInTx()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testSimpleInTx() throws Exception {
    ClientProducer producer = clientSessionTxReceives.createProducer(address);
    ClientConsumer consumer = clientSessionTxReceives.createConsumer(qName1);
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    SimpleString rh = new SimpleString("SMID1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    ClientMessage m2 = createTextMessage(clientSession, "m2");
    m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    producer.send(m1);
    producer.send(m2);
    clientSessionTxReceives.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m2");
}

28. LVQTest#testFirstMessageReceivedButAckedAfter()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testFirstMessageReceivedButAckedAfter() throws Exception {
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    SimpleString rh = new SimpleString("SMID1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    ClientMessage m2 = createTextMessage(clientSession, "m2");
    m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    producer.send(m1);
    clientSession.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    producer.send(m2);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m1");
    m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m2");
}

29. LVQTest#testSimple()

Project: activemq-artemis
File: LVQTest.java
@Test
public void testSimple() throws Exception {
    ClientProducer producer = clientSession.createProducer(address);
    ClientConsumer consumer = clientSession.createConsumer(qName1);
    ClientMessage m1 = createTextMessage(clientSession, "m1");
    SimpleString rh = new SimpleString("SMID1");
    m1.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    ClientMessage m2 = createTextMessage(clientSession, "m2");
    m2.putStringProperty(Message.HDR_LAST_VALUE_NAME, rh);
    producer.send(m1);
    producer.send(m2);
    clientSession.start();
    ClientMessage m = consumer.receive(1000);
    Assert.assertNotNull(m);
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "m2");
}

30. BatchDelayTest#testSendReceiveMany()

Project: activemq-artemis
File: BatchDelayTest.java
@Test
public void testSendReceiveMany() throws Exception {
    ClientSessionFactory sf = createSessionFactory();
    ClientSession session = sf.createSession();
    final String foo = "foo";
    session.createQueue(foo, foo);
    ClientProducer prod = session.createProducer(foo);
    ClientConsumer cons = session.createConsumer(foo);
    session.start();
    sendMessages(session, prod, N);
    receiveMessages(cons, 0, N, true);
}

31. OutgoingConnectionTestJTA#testSimpleSendNoXAJMS1()

Project: activemq-artemis
File: OutgoingConnectionTestJTA.java
@Test
public void testSimpleSendNoXAJMS1() throws Exception {
    Queue q = ActiveMQJMSClient.createQueue(MDBQUEUE);
    try (ClientSessionFactory sf = locator.createSessionFactory();
        ClientSession session = sf.createSession();
        ClientConsumer consVerify = session.createConsumer("jms.queue." + MDBQUEUE);
        Connection conn = qraConnectionFactory.createConnection()) {
        Session jmsSess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
        session.start();
        MessageProducer producer = jmsSess.createProducer(q);
        // These next 4 lines could be written in a single line however it makes difficult for debugging
        TextMessage msgsend = jmsSess.createTextMessage("hello");
        msgsend.setStringProperty("strvalue", "hello");
        producer.send(msgsend);
        ClientMessage msg = consVerify.receive(1000);
        assertNotNull(msg);
        assertEquals("hello", msg.getStringProperty("strvalue"));
    }
}

32. OutgoingConnectionTestJTA#testSimpleSendNoXAJMSContext()

Project: activemq-artemis
File: OutgoingConnectionTestJTA.java
@Test
public void testSimpleSendNoXAJMSContext() throws Exception {
    Queue q = ActiveMQJMSClient.createQueue(MDBQUEUE);
    try (ClientSessionFactory sf = locator.createSessionFactory();
        ClientSession session = sf.createSession();
        ClientConsumer consVerify = session.createConsumer("jms.queue." + MDBQUEUE);
        JMSContext jmsctx = qraConnectionFactory.createContext()) {
        session.start();
        // These next 4 lines could be written in a single line however it makes difficult for debugging
        JMSProducer producer = jmsctx.createProducer();
        producer.setProperty("strvalue", "hello");
        TextMessage msgsend = jmsctx.createTextMessage("hello");
        producer.send(q, msgsend);
        ClientMessage msg = consVerify.receive(1000);
        assertNotNull(msg);
        assertEquals("hello", msg.getStringProperty("strvalue"));
    }
}

33. ExportFormatTest#testConsumeFromFormat()

Project: activemq-artemis
File: ExportFormatTest.java
@Test
public void testConsumeFromFormat() throws Exception {
    ActiveMQServer server = createServer(true);
    DecodeJournal.importJournal(server.getConfiguration().getJournalLocation().getAbsolutePath(), "activemq-data", "amq", 2, 102400, new StringReader(journalFile));
    DecodeJournal.importJournal(server.getConfiguration().getBindingsLocation().getAbsolutePath(), "activemq-bindings", "bindings", 2, 1048576, new StringReader(bindingsFile));
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory factory = createSessionFactory(locator);
    ClientSession session = factory.createSession();
    session.start();
    ClientConsumer consumer = session.createConsumer("A1");
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = consumer.receive(5000);
        assertNotNull(msg);
        msg.acknowledge();
        assertEquals(i, msg.getIntProperty("key").intValue());
    }
    session.commit();
}

34. ManagementTestBase#consumeMessages()

Project: activemq-artemis
File: ManagementTestBase.java
// Static --------------------------------------------------------
protected static void consumeMessages(final int expected, final ClientSession session, final SimpleString queue) throws Exception {
    ClientConsumer consumer = null;
    try {
        consumer = session.createConsumer(queue);
        ClientMessage m = null;
        for (int i = 0; i < expected; i++) {
            m = consumer.receive(500);
            Assert.assertNotNull("expected to received " + expected + " messages, got only " + i, m);
            m.acknowledge();
        }
        session.commit();
        m = consumer.receiveImmediate();
        Assert.assertNull("received one more message than expected (" + expected + ")", m);
    } finally {
        if (consumer != null) {
            consumer.close();
        }
    }
}

35. MultiThreadRandomReattachTestBase#doTestO()

Project: activemq-artemis
File: MultiThreadRandomReattachTestBase.java
protected void doTestO(final ClientSessionFactory sf, final int threadNum) throws Exception {
    ClientSession sessCreate = sf.createSession(false, true, true);
    sessCreate.createQueue(MultiThreadRandomReattachTestBase.ADDRESS, new SimpleString(threadNum + MultiThreadRandomReattachTestBase.ADDRESS.toString()), null, false);
    ClientSession sess = sf.createSession(false, true, true);
    sess.start();
    ClientConsumer consumer = sess.createConsumer(new SimpleString(threadNum + MultiThreadRandomReattachTestBase.ADDRESS.toString()));
    for (int i = 0; i < 100; i++) {
        Assert.assertNull(consumer.receiveImmediate());
    }
    sess.close();
    sessCreate.deleteQueue(new SimpleString(threadNum + MultiThreadRandomReattachTestBase.ADDRESS.toString()));
    sessCreate.close();
}

36. FailoverTest#testFailWithBrowser()

Project: activemq-artemis
File: FailoverTest.java
/*
    * Browser will get reset to beginning after failover
    */
@Test
public void testFailWithBrowser() throws Exception {
    createSessionFactory();
    ClientSession session = createSession(sf, true, true);
    session.createQueue(FailoverTestBase.ADDRESS, FailoverTestBase.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
    sendMessagesSomeDurable(session, producer);
    ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS, true);
    session.start();
    receiveMessages(consumer, 0, NUM_MESSAGES, false);
    crash(session);
    receiveDurableMessages(consumer);
}

37. FailoverTest#testFailoverOnInitialConnection()

Project: activemq-artemis
File: FailoverTest.java
// https://jira.jboss.org/jira/browse/HORNETQ-285
@Test
public void testFailoverOnInitialConnection() throws Exception {
    locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true).setFailoverOnInitialConnection(true).setReconnectAttempts(-1);
    sf = createSessionFactoryAndWaitForTopology(locator, 2);
    // Crash live server
    crash();
    ClientSession session = createSession(sf);
    session.createQueue(FailoverTestBase.ADDRESS, FailoverTestBase.ADDRESS, null, true);
    ClientProducer producer = session.createProducer(FailoverTestBase.ADDRESS);
    sendMessages(session, producer, NUM_MESSAGES);
    ClientConsumer consumer = session.createConsumer(FailoverTestBase.ADDRESS);
    session.start();
    receiveMessages(consumer);
    session.close();
}

38. FailoverListenerTest#verifyMessageOnServer()

Project: activemq-artemis
File: FailoverListenerTest.java
/**
    * @throws Exception
    */
private void verifyMessageOnServer(final int server, final int numberOfMessages) throws Exception {
    ServerLocator backupLocator = createInVMLocator(server);
    ClientSessionFactory factorybkp = addSessionFactory(createSessionFactory(backupLocator));
    ClientSession sessionbkp = factorybkp.createSession(false, false);
    sessionbkp.start();
    ClientConsumer consumerbkp = sessionbkp.createConsumer(ADDRESS);
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage msg = consumerbkp.receive(1000);
        assertNotNull(msg);
        msg.acknowledge();
        sessionbkp.commit();
    }
    sessionbkp.close();
    factorybkp.close();
    backupLocator.close();
}

39. FailBackAutoTest#verifyMessageOnServer()

Project: activemq-artemis
File: FailBackAutoTest.java
/**
    * @throws Exception
    * @throws Exception
    */
private void verifyMessageOnServer(final int server, final int numberOfMessages) throws Exception {
    ServerLocator backupLocator = createInVMLocator(server);
    ClientSessionFactory factorybkp = addSessionFactory(createSessionFactory(backupLocator));
    ClientSession sessionbkp = factorybkp.createSession(false, false);
    sessionbkp.start();
    ClientConsumer consumerbkp = sessionbkp.createConsumer(ADDRESS);
    for (int i = 0; i < numberOfMessages; i++) {
        ClientMessage msg = consumerbkp.receive(1000);
        assertNotNull(msg);
        msg.acknowledge();
        sessionbkp.commit();
    }
    sessionbkp.close();
    factorybkp.close();
    backupLocator.close();
}

40. WildCardRoutingTest#testWildcardRoutingHashAndStar()

Project: activemq-artemis
File: WildCardRoutingTest.java
@Test
public void testWildcardRoutingHashAndStar() throws Exception {
    SimpleString addressAB = new SimpleString("a.b.c");
    SimpleString addressAC = new SimpleString("a.c");
    SimpleString address = new SimpleString("#.b.*");
    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);
    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.receiveImmediate();
    Assert.assertNull(m);
}

41. WildCardRoutingTest#testWildcardRoutingStarAndHash()

Project: activemq-artemis
File: WildCardRoutingTest.java
@Test
public void testWildcardRoutingStarAndHash() throws Exception {
    SimpleString addressAB = new SimpleString("a.b.c.d");
    SimpleString addressAC = new SimpleString("a.c");
    SimpleString address = new SimpleString("*.b.#");
    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);
    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.receiveImmediate();
    Assert.assertNull(m);
}

42. WildCardRoutingTest#testWildcardRoutingStarInMiddle()

Project: activemq-artemis
File: WildCardRoutingTest.java
@Test
public void testWildcardRoutingStarInMiddle() throws Exception {
    SimpleString addressAB = new SimpleString("a.b.c");
    SimpleString addressAC = new SimpleString("a.c");
    SimpleString address = new SimpleString("*.b.*");
    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);
    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.receiveImmediate();
    Assert.assertNull(m);
}

43. WildCardRoutingTest#testWildcardRoutingMultipleStars()

Project: activemq-artemis
File: WildCardRoutingTest.java
@Test
public void testWildcardRoutingMultipleStars() throws Exception {
    SimpleString addressAB = new SimpleString("a.b.c");
    SimpleString addressAC = new SimpleString("a.c");
    SimpleString address = new SimpleString("*.*");
    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);
    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("m2", m.getBodyBuffer().readString());
    m.acknowledge();
    m = clientConsumer.receiveImmediate();
    Assert.assertNull(m);
}

44. WildCardRoutingTest#testWildcardRoutingVariableLengthsStar()

Project: activemq-artemis
File: WildCardRoutingTest.java
@Test
public void testWildcardRoutingVariableLengthsStar() throws Exception {
    SimpleString addressAB = new SimpleString("a.b.c");
    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);
    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("m2", m.getBodyBuffer().readString());
    m.acknowledge();
    m = clientConsumer.receiveImmediate();
    Assert.assertNull(m);
}

45. WildCardRoutingTest#testWildcardRoutingPartialMatchStar()

Project: activemq-artemis
File: WildCardRoutingTest.java
@Test
public void testWildcardRoutingPartialMatchStar() throws Exception {
    SimpleString addressAB = new SimpleString("a.b");
    SimpleString addressAC = new SimpleString("a.c");
    SimpleString address = new SimpleString("*.b");
    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);
    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.receiveImmediate();
    Assert.assertNull(m);
}

46. TemporaryQueueTest#testConsumeFromTemporaryQueueCreatedByOtherSession()

Project: activemq-artemis
File: TemporaryQueueTest.java
@Test
public void testConsumeFromTemporaryQueueCreatedByOtherSession() throws Exception {
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString address = RandomUtil.randomSimpleString();
    session.createTemporaryQueue(address, queue);
    ClientProducer producer = session.createProducer(address);
    producer.send(session.createMessage(false));
    ClientSession session2 = sf.createSession(false, true, true);
    session2.start();
    ClientConsumer consumer = session2.createConsumer(queue);
    ClientMessage message = consumer.receive(500);
    assertNotNull(message);
    session2.close();
    session.close();
}

47. SlowConsumerTest#testSlowConsumerSpared()

Project: activemq-artemis
File: SlowConsumerTest.java
@Test
public void testSlowConsumerSpared() throws Exception {
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = addClientSession(sf.createSession(true, true));
    session.createQueue(QUEUE, QUEUE, null, false);
    ClientProducer producer = addClientProducer(session.createProducer(QUEUE));
    final int numMessages = 5;
    for (int i = 0; i < numMessages; i++) {
        producer.send(createTextMessage(session, "m" + i));
    }
    ClientConsumer consumer = addClientConsumer(session.createConsumer(QUEUE));
    session.start();
    Thread.sleep(3000);
    for (int i = 0; i < numMessages; i++) {
        assertNotNull(consumer.receive(500));
    }
}

48. SessionCloseTest#testCloseHierarchy()

Project: activemq-artemis
File: SessionCloseTest.java
@Test
public void testCloseHierarchy() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    ClientSession session = sf.createSession(false, true, true);
    session.createQueue(address, queue, false);
    ClientProducer producer = session.createProducer(address);
    ClientConsumer consumer = session.createConsumer(queue);
    session.close();
    Assert.assertTrue(session.isClosed());
    Assert.assertTrue(producer.isClosed());
    Assert.assertTrue(consumer.isClosed());
}

49. RoutingTest#testRouteToSingleTemporaryQueue()

Project: activemq-artemis
File: RoutingTest.java
@Test
public void testRouteToSingleTemporaryQueue() throws Exception {
    ClientSession sendSession = cf.createSession(false, true, true);
    sendSession.createTemporaryQueue(addressA, queueA);
    int numMessages = 300;
    ClientProducer p = sendSession.createProducer(addressA);
    for (int i = 0; i < numMessages; i++) {
        p.send(sendSession.createMessage(false));
    }
    ClientSession session = cf.createSession(false, true, true);
    ClientConsumer c1 = session.createConsumer(queueA);
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage m = c1.receive(5000);
        Assert.assertNotNull(m);
        m.acknowledge();
    }
    Assert.assertNull(c1.receiveImmediate());
    sendSession.close();
    session.close();
}

50. RoutingTest#testRouteToSingleQueueWithFilter()

Project: activemq-artemis
File: RoutingTest.java
@Test
public void testRouteToSingleQueueWithFilter() throws Exception {
    ClientSession sendSession = cf.createSession(false, true, true);
    sendSession.createQueue(addressA, queueA, new SimpleString("foo = 'bar'"), false);
    int numMessages = 300;
    ClientProducer p = sendSession.createProducer(addressA);
    for (int i = 0; i < numMessages; i++) {
        ClientMessage clientMessage = sendSession.createMessage(false);
        clientMessage.putStringProperty(new SimpleString("foo"), new SimpleString("bar"));
        p.send(clientMessage);
    }
    ClientSession session = cf.createSession(false, true, true);
    ClientConsumer c1 = session.createConsumer(queueA);
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage m = c1.receive(5000);
        Assert.assertNotNull(m);
        m.acknowledge();
    }
    Assert.assertNull(c1.receiveImmediate());
    sendSession.close();
    session.close();
}

51. RoutingTest#testRouteToSingleDurableQueue()

Project: activemq-artemis
File: RoutingTest.java
@Test
public void testRouteToSingleDurableQueue() throws Exception {
    ClientSession sendSession = cf.createSession(false, true, true);
    sendSession.createQueue(addressA, queueA, true);
    int numMessages = 300;
    ClientProducer p = sendSession.createProducer(addressA);
    for (int i = 0; i < numMessages; i++) {
        p.send(sendSession.createMessage(false));
    }
    ClientSession session = cf.createSession(false, true, true);
    ClientConsumer c1 = session.createConsumer(queueA);
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage m = c1.receive(5000);
        Assert.assertNotNull(m);
        m.acknowledge();
    }
    Assert.assertNull(c1.receiveImmediate());
    sendSession.close();
    session.close();
}

52. RoutingTest#testRouteToSingleNonDurableQueue()

Project: activemq-artemis
File: RoutingTest.java
@Test
public void testRouteToSingleNonDurableQueue() throws Exception {
    ClientSession sendSession = cf.createSession(false, true, true);
    sendSession.createQueue(addressA, queueA, false);
    int numMessages = 300;
    ClientProducer p = sendSession.createProducer(addressA);
    for (int i = 0; i < numMessages; i++) {
        p.send(sendSession.createMessage(false));
    }
    ClientSession session = cf.createSession(false, true, true);
    ClientConsumer c1 = session.createConsumer(queueA);
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage m = c1.receive(5000);
        Assert.assertNotNull(m);
        m.acknowledge();
    }
    Assert.assertNull(c1.receiveImmediate());
    sendSession.close();
    session.close();
}

53. ReceiveTest#testReceiveOnClosedException()

Project: activemq-artemis
File: ReceiveTest.java
@Test
public void testReceiveOnClosedException() throws Exception {
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession session = cf.createSession(false, true, true);
    session.createQueue(addressA, queueA, false);
    ClientConsumer cc = session.createConsumer(queueA);
    session.start();
    session.close();
    try {
        cc.receive();
        Assert.fail("should throw exception");
    } catch (ActiveMQObjectClosedException oce) {
    } catch (ActiveMQException e) {
        Assert.fail("Invalid Exception type:" + e.getType());
    }
    session.close();
}

54. ReceiveTest#testBasicReceive()

Project: activemq-artemis
File: ReceiveTest.java
@Test
public void testBasicReceive() throws Exception {
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientSession session = cf.createSession(false, true, true);
    session.createQueue(addressA, queueA, false);
    ClientConsumer cc = session.createConsumer(queueA);
    session.start();
    cp.send(sendSession.createMessage(false));
    Assert.assertNotNull(cc.receive());
    session.close();
    sendSession.close();
}

55. ReceiveImmediateTest#doConsumerReceiveImmediateWithNoMessages()

Project: activemq-artemis
File: ReceiveImmediateTest.java
private void doConsumerReceiveImmediateWithNoMessages(final boolean browser) throws Exception {
    locator.setBlockOnNonDurableSend(true).setBlockOnAcknowledge(true).setAckBatchSize(0);
    sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(ADDRESS, QUEUE, null, false);
    ClientConsumer consumer = session.createConsumer(QUEUE, null, browser);
    session.start();
    ClientMessage message = consumer.receiveImmediate();
    Assert.assertNull(message);
    session.close();
}

56. NewDeadLetterAddressTest#testSendToDLAWhenNoRoute()

Project: activemq-artemis
File: NewDeadLetterAddressTest.java
@Test
public void testSendToDLAWhenNoRoute() throws Exception {
    SimpleString dla = new SimpleString("DLA");
    SimpleString address = new SimpleString("empty_address");
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dla).setSendToDLAOnNoRoute(true);
    server.getAddressSettingsRepository().addMatch(address.toString(), addressSettings);
    SimpleString dlq = new SimpleString("DLQ1");
    clientSession.createQueue(dla, dlq, null, false);
    ClientProducer producer = clientSession.createProducer(address);
    producer.send(createTextMessage(clientSession, "heyho!"));
    clientSession.start();
    ClientConsumer clientConsumer = clientSession.createConsumer(dlq);
    ClientMessage m = clientConsumer.receive(500);
    m.acknowledge();
    Assert.assertNotNull(m);
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
}

57. DeliveryOrderTest#testSendDeliveryOrderOnCommit()

Project: activemq-artemis
File: DeliveryOrderTest.java
@Test
public void testSendDeliveryOrderOnCommit() throws Exception {
    ClientSession sendSession = cf.createSession(false, false, true);
    ClientProducer cp = sendSession.createProducer(addressA);
    int numMessages = 1000;
    sendSession.createQueue(addressA, queueA, false);
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = sendSession.createMessage(false);
        cm.getBodyBuffer().writeInt(i);
        cp.send(cm);
        if (i % 10 == 0) {
            sendSession.commit();
        }
        sendSession.commit();
    }
    ClientConsumer c = sendSession.createConsumer(queueA);
    sendSession.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = c.receive(5000);
        Assert.assertNotNull(cm);
        Assert.assertEquals(i, cm.getBodyBuffer().readInt());
    }
    sendSession.close();
}

58. ConsumerTest#testInVMURI()

Project: activemq-artemis
File: ConsumerTest.java
// https://jira.jboss.org/jira/browse/HORNETQ-111
// Test that, on rollback credits are released for messages cleared in the buffer
@Test
public void testInVMURI() throws Exception {
    locator.close();
    ServerLocator locator = addServerLocator(ServerLocatorImpl.newLocator("vm:/1"));
    ClientSessionFactory factory = locator.createSessionFactory();
    ClientSession session = factory.createSession();
    session.createQueue(QUEUE, QUEUE);
    ClientProducer producer = session.createProducer(QUEUE);
    producer.send(session.createMessage(true));
    ClientConsumer consumer = session.createConsumer(QUEUE);
    session.start();
    Assert.assertNotNull(consumer.receiveImmediate());
    session.close();
    factory.close();
}

59. MessagePropertyTest#receiveMessages()

Project: activemq-artemis
File: MessagePropertyTest.java
private void receiveMessages() throws Exception {
    ClientSession session = sf.createSession(true, true);
    session.start();
    try (ClientConsumer consumer = session.createConsumer(ADDRESS)) {
        for (int i = 0; i < numMessages; i++) {
            ClientMessage message = consumer.receive(100);
            assertNotNull("Expecting a message " + i, message);
            assertMessageBody(i, message);
            assertEquals(i, message.getIntProperty("int").intValue());
            assertEquals((short) i, message.getShortProperty("short").shortValue());
            assertEquals((byte) i, message.getByteProperty("byte").byteValue());
            assertEquals(floatValue(i), message.getFloatProperty("float").floatValue(), 0.001);
            assertEquals(new SimpleString(Integer.toString(i)), message.getSimpleStringProperty(SIMPLE_STRING_KEY.toString()));
            assertEqualsByteArrays(byteArray(i), message.getBytesProperty("byte[]"));
            assertTrue(message.containsProperty("null-value"));
            assertEquals(message.getObjectProperty("null-value"), null);
            message.acknowledge();
        }
        assertNull("no more messages", consumer.receive(50));
    }
    session.commit();
}

60. ClientSessionImpl#closeChildren()

Project: activemq-artemis
File: ClientSessionImpl.java
private void closeChildren() throws ActiveMQException {
    Set<ClientConsumerInternal> consumersClone = cloneConsumers();
    for (ClientConsumer consumer : consumersClone) {
        consumer.close();
    }
    Set<ClientProducerInternal> producersClone = cloneProducers();
    for (ClientProducer producer : producersClone) {
        producer.close();
    }
}

61. AddressSettingsTest#test3LevelHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void test3LevelHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings3 = new AddressSettings().setDeadLetterAddress(dlaC).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA2.toString(), addressSettings);
    repos.addMatch("add.*", addressSettings2);
    repos.addMatch("#", addressSettings3);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA2, queueA, false);
    session.createQueue(addressB2, queueB, false);
    session.createQueue(addressC, queueC, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    session.createQueue(dlaC, dlqC, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientMessage cm3 = sendSession.createMessage(true);
    cm3.getBodyBuffer().writeString("C");
    ClientProducer cp1 = sendSession.createProducer(addressA2);
    ClientProducer cp2 = sendSession.createProducer(addressB2);
    ClientProducer cp3 = sendSession.createProducer(addressC);
    cp1.send(cm);
    cp2.send(cm2);
    cp3.send(cm3);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer dlqCrec = session.createConsumer(dlqC);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    ClientConsumer cc3 = session.createConsumer(queueC);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc3.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    cc3.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("C", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

62. AddressSettingsTest#testOverrideHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testOverrideHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setMaxDeliveryAttempts(1);
    AddressSettings addressSettings3 = new AddressSettings().setDeadLetterAddress(dlaC).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA2.toString(), addressSettings);
    repos.addMatch("add.*", addressSettings2);
    repos.addMatch("#", addressSettings3);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA2, queueA, false);
    session.createQueue(addressB2, queueB, false);
    session.createQueue(addressC, queueC, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    session.createQueue(dlaC, dlqC, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    ClientMessage cm2 = sendSession.createMessage(true);
    ClientMessage cm3 = sendSession.createMessage(true);
    ClientProducer cp1 = sendSession.createProducer(addressA2);
    ClientProducer cp2 = sendSession.createProducer(addressB2);
    ClientProducer cp3 = sendSession.createProducer(addressC);
    cp1.send(cm);
    cp2.send(cm2);
    cp3.send(cm3);
    ClientConsumer dlqCrec = session.createConsumer(dlqC);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    ClientConsumer cc3 = session.createConsumer(queueC);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc3.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    cc3.close();
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    message = dlqCrec.receive(5000);
    Assert.assertNotNull(message);
    sendSession.close();
    session.close();
}

63. AutogroupIdTest#testGroupIdAutomaticallySetMultipleProducers()

Project: activemq-artemis
File: AutogroupIdTest.java
/*
   * tests when the autogroupid is set only 2 consumers (out of 3) gets all the messages from 2 producers
   * */
@Test
public void testGroupIdAutomaticallySetMultipleProducers() throws Exception {
    locator.setAutoGroup(true);
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    session.createQueue(groupTestQ, groupTestQ, null, false);
    ClientProducer producer = session.createProducer(groupTestQ);
    ClientProducer producer2 = session.createProducer(groupTestQ);
    final CountDownLatch latch = new CountDownLatch(200);
    MyMessageHandler myMessageHandler = new MyMessageHandler(latch);
    MyMessageHandler myMessageHandler2 = new MyMessageHandler(latch);
    MyMessageHandler myMessageHandler3 = new MyMessageHandler(latch);
    ClientConsumer consumer = session.createConsumer(groupTestQ);
    consumer.setMessageHandler(myMessageHandler);
    ClientConsumer consumer2 = session.createConsumer(groupTestQ);
    consumer2.setMessageHandler(myMessageHandler2);
    ClientConsumer consumer3 = session.createConsumer(groupTestQ);
    consumer3.setMessageHandler(myMessageHandler3);
    session.start();
    final int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        producer.send(session.createMessage(false));
    }
    for (int i = 0; i < numMessages; i++) {
        producer2.send(session.createMessage(false));
    }
    waitForLatch(latch);
    session.close();
    Assert.assertEquals(myMessageHandler.messagesReceived, 100);
    Assert.assertEquals(myMessageHandler2.messagesReceived, 100);
    Assert.assertEquals(myMessageHandler3.messagesReceived, 0);
}

64. AddressSettingsTest#test2LevelWordHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void test2LevelWordHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA.toString(), addressSettings);
    repos.addMatch("*", addressSettings2);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA, queueA, false);
    session.createQueue(addressB, queueB, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientProducer cp1 = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    cp1.send(cm);
    cp2.send(cm2);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

65. AddressSettingsTest#test2LevelHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void test2LevelHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA.toString(), addressSettings);
    repos.addMatch("#", addressSettings2);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA, queueA, false);
    session.createQueue(addressB, queueB, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientProducer cp1 = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    cp1.send(cm);
    cp2.send(cm2);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

66. AddressSettingsTest#testSimpleHierarchyWithDLA()

Project: activemq-artemis
File: AddressSettingsTest.java
@Test
public void testSimpleHierarchyWithDLA() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(dlaA).setMaxDeliveryAttempts(1);
    AddressSettings addressSettings2 = new AddressSettings().setDeadLetterAddress(dlaB).setMaxDeliveryAttempts(1);
    HierarchicalRepository<AddressSettings> repos = server.getAddressSettingsRepository();
    repos.addMatch(addressA.toString(), addressSettings);
    repos.addMatch(addressB.toString(), addressSettings2);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, false);
    session.createQueue(addressA, queueA, false);
    session.createQueue(addressB, queueB, false);
    session.createQueue(dlaA, dlqA, false);
    session.createQueue(dlaB, dlqB, false);
    ClientSession sendSession = sf.createSession(false, true, true);
    ClientMessage cm = sendSession.createMessage(true);
    cm.getBodyBuffer().writeString("A");
    ClientMessage cm2 = sendSession.createMessage(true);
    cm2.getBodyBuffer().writeString("B");
    ClientProducer cp1 = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    cp1.send(cm);
    cp2.send(cm2);
    ClientConsumer dlqARec = session.createConsumer(dlqA);
    ClientConsumer dlqBrec = session.createConsumer(dlqB);
    ClientConsumer cc1 = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    session.start();
    ClientMessage message = cc1.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    message = cc2.receive(5000);
    Assert.assertNotNull(message);
    message.acknowledge();
    session.rollback();
    cc1.close();
    cc2.close();
    message = dlqARec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("A", message.getBodyBuffer().readString());
    message = dlqBrec.receive(5000);
    Assert.assertNotNull(message);
    Assert.assertEquals("B", message.getBodyBuffer().readString());
    sendSession.close();
    session.close();
}

67. LegacyLDAPSecuritySettingPluginListenerTest#testConsumerPermissionUpdate()

Project: activemq-artemis
File: LegacyLDAPSecuritySettingPluginListenerTest.java
@Test
public void testConsumerPermissionUpdate() throws Exception {
    server.getConfiguration().setSecurityInvalidationInterval(0);
    server.start();
    ClientSessionFactory cf = locator.createSessionFactory();
    String queue = "queue1";
    ClientSession session = cf.createSession("first", "secret", false, true, true, false, 0);
    ClientSession session2 = cf.createSession("second", "secret", false, true, true, false, 0);
    session.createQueue(SimpleString.toSimpleString(queue), SimpleString.toSimpleString(queue));
    ClientConsumer consumer = session.createConsumer(queue);
    consumer.receiveImmediate();
    consumer.close();
    ClientConsumer consumer2 = null;
    try {
        session2.createConsumer(queue);
        Assert.fail("Consuming here should fail due to the original security data.");
    } catch (ActiveMQException e) {
    }
    DirContext ctx = getContext();
    BasicAttributes basicAttributes = new BasicAttributes();
    basicAttributes.put("uniquemember", "uid=role2");
    ctx.modifyAttributes("cn=read,uid=queue1,ou=queues,ou=destinations,o=ActiveMQ,ou=system", DirContext.REPLACE_ATTRIBUTE, basicAttributes);
    ctx.close();
    consumer2 = session2.createConsumer(queue);
    consumer2.receiveImmediate();
    consumer2.close();
    try {
        session.createConsumer(queue);
        Assert.fail("Sending here should fail due to the modified security data.");
    } catch (ActiveMQException e) {
    }
    cf.close();
}

68. ScheduledMessageTest#testPagedMessageDeliveredMultipleConsumersAfterRecoverCorrectly()

Project: activemq-artemis
File: ScheduledMessageTest.java
@Test
public void testPagedMessageDeliveredMultipleConsumersAfterRecoverCorrectly() 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);
    Assert.assertNotNull(message3);
    message3.acknowledge();
    ClientMessage message2 = consumer2.receive(1000);
    Assert.assertNotNull(message2);
    message2.acknowledge();
    Assert.assertEquals("m1", message3.getBodyBuffer().readString());
    Assert.assertEquals("m1", message2.getBodyBuffer().readString());
    long time = System.currentTimeMillis();
    // force redelivery
    consumer.close();
    consumer2.close();
    session.rollback();
    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);
    consumer2 = session.createConsumer(atestq2);
    session.start();
    message3 = consumer.receive(5250);
    Assert.assertNotNull(message3);
    message2 = consumer2.receive(1000);
    Assert.assertNotNull(message2);
    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();
}

69. ScheduledMessageTest#testPagedMessageDeliveredMultipleConsumersCorrectly()

Project: activemq-artemis
File: ScheduledMessageTest.java
@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();
}

70. MessageGroupingTest#doTestMultipleGrouping()

Project: activemq-artemis
File: MessageGroupingTest.java
private void doTestMultipleGrouping() throws Exception {
    ClientProducer clientProducer = clientSession.createProducer(qName);
    ClientConsumer consumer = clientSession.createConsumer(qName);
    ClientConsumer consumer2 = clientSession.createConsumer(qName);
    clientSession.start();
    SimpleString groupId = new SimpleString("grp1");
    SimpleString groupId2 = new SimpleString("grp2");
    int numMessages = 4;
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = createTextMessage(clientSession, "m" + i);
        if (i % 2 == 0 || i == 0) {
            message.putStringProperty(Message.HDR_GROUP_ID, groupId);
        } else {
            message.putStringProperty(Message.HDR_GROUP_ID, groupId2);
        }
        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(numMessages / 2, dummyMessageHandler.list.size());
    int i = 0;
    for (ClientMessage message : dummyMessageHandler.list) {
        Assert.assertEquals(message.getBodyBuffer().readString(), "m" + i);
        i += 2;
    }
    Assert.assertEquals(numMessages / 2, dummyMessageHandler2.list.size());
    i = 1;
    for (ClientMessage message : dummyMessageHandler2.list) {
        Assert.assertEquals(message.getBodyBuffer().readString(), "m" + i);
        i += 2;
    }
    consumer.close();
    consumer2.close();
}

71. MessageGroupingTest#dotestMultipleGroupingXACommit()

Project: activemq-artemis
File: MessageGroupingTest.java
private void dotestMultipleGroupingXACommit() throws Exception {
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sessionFactory = createSessionFactory(locator);
    ClientSession clientSession = sessionFactory.createSession(true, false, false);
    ClientProducer clientProducer = this.clientSession.createProducer(qName);
    ClientConsumer consumer = clientSession.createConsumer(qName);
    ClientConsumer consumer2 = clientSession.createConsumer(qName);
    clientSession.start();
    Xid xid = new XidImpl("bq".getBytes(), 4, "gtid".getBytes());
    clientSession.start(xid, XAResource.TMNOFLAGS);
    SimpleString groupId = new SimpleString("grp1");
    SimpleString groupId2 = new SimpleString("grp2");
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = createTextMessage(clientSession, "m" + i);
        if (i % 2 == 0 || i == 0) {
            message.putStringProperty(Message.HDR_GROUP_ID, groupId);
        } else {
            message.putStringProperty(Message.HDR_GROUP_ID, groupId2);
        }
        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));
    clientSession.end(xid, XAResource.TMSUCCESS);
    clientSession.prepare(xid);
    clientSession.commit(xid, false);
    Assert.assertEquals(dummyMessageHandler.list.size(), 50);
    int i = 0;
    for (ClientMessage message : dummyMessageHandler.list) {
        Assert.assertEquals(message.getBodyBuffer().readString(), "m" + i);
        i += 2;
    }
    Assert.assertEquals(dummyMessageHandler2.list.size(), 50);
    i = 1;
    for (ClientMessage message : dummyMessageHandler2.list) {
        Assert.assertEquals(message.getBodyBuffer().readString(), "m" + i);
        i += 2;
    }
    consumer.close();
    consumer2.close();
    consumer = this.clientSession.createConsumer(qName);
    Assert.assertNull(consumer.receiveImmediate());
    clientSession.close();
    locator.close();
}

72. MessageGroupingTest#doTestMultipleGroupingTXCommit()

Project: activemq-artemis
File: MessageGroupingTest.java
private void doTestMultipleGroupingTXCommit() throws Exception {
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sessionFactory = createSessionFactory(locator);
    ClientSession clientSession = sessionFactory.createSession(false, false, false);
    ClientProducer clientProducer = this.clientSession.createProducer(qName);
    clientSession.start();
    ClientConsumer consumer = clientSession.createConsumer(qName);
    ClientConsumer consumer2 = clientSession.createConsumer(qName);
    //Wait a bit otherwise consumers might be busy
    Thread.sleep(200);
    SimpleString groupId = new SimpleString("grp1");
    SimpleString groupId2 = new SimpleString("grp2");
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = createTextMessage(clientSession, "m" + i);
        if (i % 2 == 0 || i == 0) {
            message.putStringProperty(Message.HDR_GROUP_ID, groupId);
        } else {
            message.putStringProperty(Message.HDR_GROUP_ID, groupId2);
        }
        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));
    clientSession.commit();
    Assert.assertEquals(dummyMessageHandler.list.size(), 50);
    int i = 0;
    for (ClientMessage message : dummyMessageHandler.list) {
        Assert.assertEquals(message.getBodyBuffer().readString(), "m" + i);
        i += 2;
    }
    Assert.assertEquals(dummyMessageHandler2.list.size(), 50);
    i = 1;
    for (ClientMessage message : dummyMessageHandler2.list) {
        Assert.assertEquals(message.getBodyBuffer().readString(), "m" + i);
        i += 2;
    }
    consumer.close();
    consumer2.close();
    consumer = this.clientSession.createConsumer(qName);
    Assert.assertNull(consumer.receiveImmediate());
    clientSession.close();
    locator.close();
}

73. MessageGroupingConnectionFactoryTest#doTestBasicGroupingMultipleProducers()

Project: activemq-artemis
File: MessageGroupingConnectionFactoryTest.java
private void doTestBasicGroupingMultipleProducers() throws Exception {
    ClientProducer clientProducer = clientSession.createProducer(qName);
    ClientProducer clientProducer2 = clientSession.createProducer(qName);
    ClientProducer clientProducer3 = 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);
        clientProducer2.send(message);
        clientProducer3.send(message);
    }
    CountDownLatch latch = new CountDownLatch(numMessages * 3);
    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(300, dummyMessageHandler.list.size());
    Assert.assertEquals(0, dummyMessageHandler2.list.size());
    consumer.close();
    consumer2.close();
}

74. ProducerFlowControlTest#testMultipleConsumers()

Project: activemq-artemis
File: ProducerFlowControlTest.java
// Not technically a flow control test, but what the hell
@Test
public void testMultipleConsumers() throws Exception {
    server = createServer(false, isNetty());
    server.start();
    waitForServerToStart(server);
    sf = createSessionFactory(locator);
    session = sf.createSession(false, true, true, true);
    session.createQueue("address", "queue1", null, false);
    session.createQueue("address", "queue2", null, false);
    session.createQueue("address", "queue3", null, false);
    session.createQueue("address", "queue4", null, false);
    session.createQueue("address", "queue5", null, false);
    ClientConsumer consumer1 = session.createConsumer("queue1");
    ClientConsumer consumer2 = session.createConsumer("queue2");
    ClientConsumer consumer3 = session.createConsumer("queue3");
    ClientConsumer consumer4 = session.createConsumer("queue4");
    ClientConsumer consumer5 = session.createConsumer("queue5");
    ClientProducer producer = session.createProducer("address");
    byte[] bytes = new byte[2000];
    ClientMessage message = session.createMessage(false);
    message.getBodyBuffer().writeBytes(bytes);
    final int numMessages = 1000;
    for (int i = 0; i < numMessages; i++) {
        producer.send(message);
    }
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage msg = consumer1.receive(1000);
        Assert.assertNotNull(msg);
        msg = consumer2.receive(5000);
        Assert.assertNotNull(msg);
        msg = consumer3.receive(5000);
        Assert.assertNotNull(msg);
        msg = consumer4.receive(5000);
        Assert.assertNotNull(msg);
        msg = consumer5.receive(5000);
        Assert.assertNotNull(msg);
    }
}

75. LargeMessageTest#testDLAOnExpiry()

Project: activemq-artemis
File: LargeMessageTest.java
@Test
public void testDLAOnExpiry() throws Exception {
    final int messageSize = (int) (3.5 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);
    ClientSession session = null;
    ActiveMQServer server = createServer(true, isNetty(), storeType);
    server.start();
    ClientSessionFactory sf = addSessionFactory(createSessionFactory(locator));
    SimpleString ADDRESS_DLA = ADDRESS.concat("-dla");
    SimpleString ADDRESS_EXPIRY = ADDRESS.concat("-expiry");
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(ADDRESS_DLA).setExpiryAddress(ADDRESS_EXPIRY).setMaxDeliveryAttempts(1);
    server.getAddressSettingsRepository().addMatch("*", addressSettings);
    session = sf.createSession(false, false, false);
    session.createQueue(ADDRESS, ADDRESS, true);
    session.createQueue(ADDRESS_DLA, ADDRESS_DLA, true);
    session.createQueue(ADDRESS_EXPIRY, ADDRESS_EXPIRY, true);
    ClientProducer producer = session.createProducer(ADDRESS);
    Message clientFile = createLargeClientMessageStreaming(session, messageSize, true);
    clientFile.setExpiration(System.currentTimeMillis());
    producer.send(clientFile);
    session.commit();
    session.start();
    ClientConsumer consumerExpired = session.createConsumer(ADDRESS);
    // to kick expiry quicker than waiting reaper thread
    Assert.assertNull(consumerExpired.receiveImmediate());
    consumerExpired.close();
    ClientConsumer consumerExpiry = session.createConsumer(ADDRESS_EXPIRY);
    ClientMessage msg1 = consumerExpiry.receive(5000);
    Assert.assertNotNull(msg1);
    msg1.acknowledge();
    for (int j = 0; j < messageSize; j++) {
        Assert.assertEquals(ActiveMQTestBase.getSamplebyte(j), msg1.getBodyBuffer().readByte());
    }
    session.rollback();
    consumerExpiry.close();
    for (int i = 0; i < 10; i++) {
        consumerExpiry = session.createConsumer(ADDRESS_DLA);
        msg1 = consumerExpiry.receive(5000);
        Assert.assertNotNull(msg1);
        msg1.acknowledge();
        for (int j = 0; j < messageSize; j++) {
            Assert.assertEquals(ActiveMQTestBase.getSamplebyte(j), msg1.getBodyBuffer().readByte());
        }
        session.rollback();
        consumerExpiry.close();
    }
    session.close();
    server.stop();
    server = createServer(true, isNetty(), storeType);
    server.start();
    sf = createSessionFactory(locator);
    session = sf.createSession(false, false, false);
    session.start();
    consumerExpiry = session.createConsumer(ADDRESS_DLA);
    msg1 = consumerExpiry.receive(5000);
    Assert.assertNotNull(msg1);
    msg1.acknowledge();
    for (int i = 0; i < messageSize; i++) {
        Assert.assertEquals(ActiveMQTestBase.getSamplebyte(i), msg1.getBodyBuffer().readByte());
    }
    session.commit();
    consumerExpiry.close();
    session.commit();
    session.close();
    validateNoFilesOnLargeDir();
}

76. LargeMessageTest#testDLAOnExpiryNonDurableMessage()

Project: activemq-artemis
File: LargeMessageTest.java
@Test
public void testDLAOnExpiryNonDurableMessage() throws Exception {
    final int messageSize = (int) (3.5 * ActiveMQClient.DEFAULT_MIN_LARGE_MESSAGE_SIZE);
    ClientSession session = null;
    ActiveMQServer server = createServer(true, isNetty(), storeType);
    server.start();
    ClientSessionFactory sf = addSessionFactory(createSessionFactory(locator));
    SimpleString ADDRESS_DLA = ADDRESS.concat("-dla");
    SimpleString ADDRESS_EXPIRY = ADDRESS.concat("-expiry");
    AddressSettings addressSettings = new AddressSettings().setDeadLetterAddress(ADDRESS_DLA).setExpiryAddress(ADDRESS_EXPIRY).setMaxDeliveryAttempts(1);
    server.getAddressSettingsRepository().addMatch("*", addressSettings);
    session = sf.createSession(false, false, false);
    session.createQueue(ADDRESS, ADDRESS, true);
    session.createQueue(ADDRESS_DLA, ADDRESS_DLA, true);
    session.createQueue(ADDRESS_EXPIRY, ADDRESS_EXPIRY, true);
    ClientProducer producer = session.createProducer(ADDRESS);
    Message clientFile = createLargeClientMessageStreaming(session, messageSize, false);
    clientFile.setExpiration(System.currentTimeMillis());
    producer.send(clientFile);
    session.commit();
    session.start();
    ClientConsumer consumerExpired = session.createConsumer(ADDRESS);
    // to kick expiry quicker than waiting reaper thread
    Assert.assertNull(consumerExpired.receiveImmediate());
    consumerExpired.close();
    ClientConsumer consumerExpiry = session.createConsumer(ADDRESS_EXPIRY);
    ClientMessage msg1 = consumerExpiry.receive(5000);
    assertTrue(msg1.isLargeMessage());
    Assert.assertNotNull(msg1);
    msg1.acknowledge();
    for (int j = 0; j < messageSize; j++) {
        Assert.assertEquals(ActiveMQTestBase.getSamplebyte(j), msg1.getBodyBuffer().readByte());
    }
    session.rollback();
    consumerExpiry.close();
    for (int i = 0; i < 10; i++) {
        consumerExpiry = session.createConsumer(ADDRESS_DLA);
        msg1 = consumerExpiry.receive(5000);
        Assert.assertNotNull(msg1);
        msg1.acknowledge();
        for (int j = 0; j < messageSize; j++) {
            Assert.assertEquals(ActiveMQTestBase.getSamplebyte(j), msg1.getBodyBuffer().readByte());
        }
        session.rollback();
        consumerExpiry.close();
    }
    session.close();
    session = sf.createSession(false, false, false);
    session.start();
    consumerExpiry = session.createConsumer(ADDRESS_DLA);
    msg1 = consumerExpiry.receive(5000);
    Assert.assertNotNull(msg1);
    msg1.acknowledge();
    for (int i = 0; i < messageSize; i++) {
        Assert.assertEquals(ActiveMQTestBase.getSamplebyte(i), msg1.getBodyBuffer().readByte());
    }
    session.commit();
    consumerExpiry.close();
    session.commit();
    session.close();
    server.stop();
    server.start();
    validateNoFilesOnLargeDir();
}

77. TransientQueueTest#testMultipleConsumers()

Project: activemq-artemis
File: TransientQueueTest.java
@Test
public void testMultipleConsumers() throws Exception {
    SimpleString queue = SimpleString.toSimpleString("queue");
    SimpleString address = SimpleString.toSimpleString("address");
    session.createSharedQueue(address, queue, false);
    assertEquals(1, server.getConnectionCount());
    assertNotNull(server.locateQueue(queue));
    ServerLocator locator2 = createLocator();
    ClientSessionFactory sf2 = locator2.createSessionFactory();
    ClientSession session2 = sf2.createSession(false, false);
    // At this point this has no effect, other than making sure the queue exists...
    // the JMS implementation will certainly create the queue again when dealing with
    // non durable shared subscriptions
    session2.createSharedQueue(address, queue, false);
    ClientConsumer consumer1 = session.createConsumer(queue);
    ClientConsumer consumer2 = session2.createConsumer(queue);
    session.start();
    session2.start();
    ClientProducer producer = session.createProducer(address);
    for (int i = 0; i < 1000; i++) {
        ClientMessage msg = session.createMessage(false);
        producer.send(msg);
    }
    ClientMessage msg;
    for (int i = 0; i < 500; i++) {
        msg = consumer1.receive(1000);
        assertNotNull(msg);
        msg.acknowledge();
        msg = consumer2.receive(1000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    assertNull(consumer1.receiveImmediate());
    assertNull(consumer2.receiveImmediate());
    for (int i = 0; i < 1000; i++) {
        msg = session.createMessage(false);
        producer.send(msg);
    }
    msg = consumer1.receiveImmediate();
    assertNotNull(msg);
    msg.acknowledge();
    msg = consumer2.receiveImmediate();
    assertNotNull(msg);
    msg.acknowledge();
    consumer1.close();
    consumer2.close();
    session.createSharedQueue(address, queue, false);
    consumer1 = session.createConsumer(queue);
    // validate if the queue was deleted after the consumer was closed
    assertNotNull(server.locateQueue(queue));
    assertNull(consumer1.receiveImmediate());
    consumer1.close();
    assertNull(server.locateQueue(queue));
}

78. ExpiryAddressTest#testBasicSendToMultipleQueues()

Project: activemq-artemis
File: ExpiryAddressTest.java
@Test
public void testBasicSendToMultipleQueues() throws Exception {
    SimpleString ea = new SimpleString("EA");
    SimpleString qName = new SimpleString("q1");
    SimpleString eq = new SimpleString("EQ1");
    SimpleString eq2 = new SimpleString("EQ2");
    AddressSettings addressSettings = new AddressSettings().setExpiryAddress(ea);
    server.getAddressSettingsRepository().addMatch(qName.toString(), addressSettings);
    clientSession.createQueue(ea, eq, null, false);
    clientSession.createQueue(ea, eq2, null, false);
    clientSession.createQueue(qName, qName, null, false);
    ClientProducer producer = clientSession.createProducer(qName);
    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);
    clientConsumer.close();
    clientConsumer = clientSession.createConsumer(eq);
    m = clientConsumer.receive(500);
    Assert.assertNotNull(m);
    assertNotNull(m.getStringProperty(Message.HDR_ORIGINAL_ADDRESS));
    assertNotNull(m.getStringProperty(Message.HDR_ORIGINAL_QUEUE));
    ExpiryAddressTest.log.info("acking");
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
    clientConsumer.close();
    clientConsumer = clientSession.createConsumer(eq2);
    m = clientConsumer.receive(500);
    Assert.assertNotNull(m);
    assertNotNull(m.getStringProperty(Message.HDR_ORIGINAL_ADDRESS));
    assertNotNull(m.getStringProperty(Message.HDR_ORIGINAL_QUEUE));
    ExpiryAddressTest.log.info("acking");
    m.acknowledge();
    Assert.assertEquals(m.getBodyBuffer().readString(), "heyho!");
    clientConsumer.close();
    clientSession.commit();
}

79. DeadLetterAddressTest#testBasicSendToMultipleQueues()

Project: activemq-artemis
File: DeadLetterAddressTest.java
@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();
}

80. CommitRollbackTest#testReceiveWithRollbackMultipleConsumersDifferentQueues()

Project: activemq-artemis
File: CommitRollbackTest.java
@Test
public void testReceiveWithRollbackMultipleConsumersDifferentQueues() throws Exception {
    ActiveMQServer server = createServer(false);
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory cf = createSessionFactory(locator);
    ClientSession sendSession = cf.createSession(false, true, true);
    ClientSession session = cf.createSession(false, false, false);
    sendSession.createQueue(addressA, queueA, false);
    sendSession.createQueue(addressB, queueB, false);
    ClientProducer cp = sendSession.createProducer(addressA);
    ClientProducer cp2 = sendSession.createProducer(addressB);
    ClientConsumer cc = session.createConsumer(queueA);
    ClientConsumer cc2 = session.createConsumer(queueB);
    int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        cp.send(sendSession.createMessage(false));
        cp2.send(sendSession.createMessage(false));
    }
    session.start();
    for (int i = 0; i < numMessages; i++) {
        ClientMessage cm = cc.receive(5000);
        Assert.assertNotNull(cm);
        cm.acknowledge();
        cm = cc2.receive(5000);
        Assert.assertNotNull(cm);
        cm.acknowledge();
    }
    Queue q = (Queue) server.getPostOffice().getBinding(queueA).getBindable();
    Queue q2 = (Queue) server.getPostOffice().getBinding(queueB).getBindable();
    Assert.assertEquals(numMessages, q.getDeliveringCount());
    cc.close();
    cc2.close();
    session.rollback();
    Assert.assertEquals(0, q2.getDeliveringCount());
    Assert.assertEquals(numMessages, getMessageCount(q));
    Assert.assertEquals(0, q2.getDeliveringCount());
    Assert.assertEquals(numMessages, getMessageCount(q));
    sendSession.close();
    session.close();
}

81. AutogroupIdTest#testGroupIdAutomaticallyNotSet()

Project: activemq-artemis
File: AutogroupIdTest.java
/*
   * tests that even though we have a grouping round robin distributor we don't pin the consumer as autogroup is false
   * */
@Test
public void testGroupIdAutomaticallyNotSet() throws Exception {
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    session.createQueue(groupTestQ, groupTestQ, null, false);
    ClientProducer producer = session.createProducer(groupTestQ);
    final CountDownLatch latch = new CountDownLatch(100);
    MyMessageHandler myMessageHandler = new MyMessageHandler(latch);
    MyMessageHandler myMessageHandler2 = new MyMessageHandler(latch);
    ClientConsumer consumer = session.createConsumer(groupTestQ);
    consumer.setMessageHandler(myMessageHandler);
    ClientConsumer consumer2 = session.createConsumer(groupTestQ);
    consumer2.setMessageHandler(myMessageHandler2);
    session.start();
    final int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        producer.send(session.createMessage(false));
    }
    waitForLatch(latch);
    session.close();
    Assert.assertEquals(50, myMessageHandler.messagesReceived);
    Assert.assertEquals(50, myMessageHandler2.messagesReceived);
}

82. AutogroupIdTest#testGroupIdAutomaticallySet()

Project: activemq-artemis
File: AutogroupIdTest.java
/*
   * tests when the autogroupid is set only 1 consumer (out of 2) gets all the messages from a single producer
   * */
@Test
public void testGroupIdAutomaticallySet() throws Exception {
    locator.setAutoGroup(true);
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    session.createQueue(groupTestQ, groupTestQ, null, false);
    ClientProducer producer = session.createProducer(groupTestQ);
    final CountDownLatch latch = new CountDownLatch(100);
    MyMessageHandler myMessageHandler = new MyMessageHandler(latch);
    MyMessageHandler myMessageHandler2 = new MyMessageHandler(latch);
    ClientConsumer consumer = session.createConsumer(groupTestQ);
    consumer.setMessageHandler(myMessageHandler);
    ClientConsumer consumer2 = session.createConsumer(groupTestQ);
    consumer2.setMessageHandler(myMessageHandler2);
    log.info("starting session");
    session.start();
    final int numMessages = 100;
    for (int i = 0; i < numMessages; i++) {
        producer.send(session.createMessage(false));
    }
    waitForLatch(latch);
    session.close();
    log.info(myMessageHandler2.messagesReceived);
    Assert.assertEquals(100, myMessageHandler.messagesReceived);
    Assert.assertEquals(0, myMessageHandler2.messagesReceived);
}

83. QueueControlTest#testMoveMessagesBack2()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testMoveMessagesBack2() throws Exception {
    server.createQueue(new SimpleString("q1"), new SimpleString("q1"), null, true, false);
    server.createQueue(new SimpleString("q2"), new SimpleString("q2"), null, true, false);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true);
    ClientProducer prod1 = session.createProducer("q1");
    int NUMBER_OF_MSGS = 10;
    for (int i = 0; i < NUMBER_OF_MSGS; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.putStringProperty(Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString("dupl-" + i));
        prod1.send(msg);
    }
    session.commit();
    ClientConsumer consumer = session.createConsumer("q1", true);
    session.start();
    assertNotNull(consumer.receive(5000));
    consumer.close();
    QueueControl q1Control = ManagementControlHelper.createQueueControl(new SimpleString("q1"), new SimpleString("q1"), mbeanServer);
    QueueControl q2Control = ManagementControlHelper.createQueueControl(new SimpleString("q2"), new SimpleString("q2"), mbeanServer);
    assertEquals(NUMBER_OF_MSGS, q1Control.moveMessages(null, "q2"));
    long[] messageIDs = new long[NUMBER_OF_MSGS];
    consumer = session.createConsumer("q2", true);
    for (int i = 0; i < NUMBER_OF_MSGS; i++) {
        ClientMessage msg = consumer.receive(5000);
        assertNotNull(msg);
        messageIDs[i] = msg.getMessageID();
    }
    assertNull(consumer.receiveImmediate());
    consumer.close();
    for (int i = 0; i < NUMBER_OF_MSGS; i++) {
        q2Control.moveMessage(messageIDs[i], "q1");
    }
    session.start();
    consumer = session.createConsumer("q1");
    for (int i = 0; i < NUMBER_OF_MSGS; i++) {
        ClientMessage msg = consumer.receive(5000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    consumer.close();
    session.deleteQueue("q1");
    session.deleteQueue("q2");
    session.close();
}

84. QueueControlTest#testMoveMessagesBack()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testMoveMessagesBack() throws Exception {
    server.createQueue(new SimpleString("q1"), new SimpleString("q1"), null, true, false);
    server.createQueue(new SimpleString("q2"), new SimpleString("q2"), null, true, false);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true);
    ClientProducer prod1 = session.createProducer("q1");
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.putStringProperty(Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString("dupl-" + i));
        prod1.send(msg);
    }
    session.commit();
    ClientConsumer consumer = session.createConsumer("q1", true);
    session.start();
    assertNotNull(consumer.receive(5000));
    consumer.close();
    QueueControl q1Control = ManagementControlHelper.createQueueControl(new SimpleString("q1"), new SimpleString("q1"), mbeanServer);
    QueueControl q2Control = ManagementControlHelper.createQueueControl(new SimpleString("q2"), new SimpleString("q2"), mbeanServer);
    assertEquals(10, q1Control.moveMessages(null, "q2"));
    consumer = session.createConsumer("q2", true);
    assertNotNull(consumer.receive(500));
    consumer.close();
    q2Control.moveMessages(null, "q1", false);
    session.start();
    consumer = session.createConsumer("q1");
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = consumer.receive(5000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    consumer.close();
    session.deleteQueue("q1");
    session.deleteQueue("q2");
    session.close();
    locator.close();
}

85. QueueControlTest#testMoveMessagesWithFilter()

Project: activemq-artemis
File: QueueControlTest.java
/**
    * <ol>
    * <li>send 2 message to queue</li>
    * <li>move messages from queue to otherQueue using management method <em>with filter</em></li>
    * <li>consume the message which <strong>did not</strong> matches the filter from queue</li>
    * <li>consume the message which <strong>did</strong> matches the filter from otherQueue</li>
    * </ol>
    */
@Test
public void testMoveMessagesWithFilter() throws Exception {
    SimpleString key = new SimpleString("key");
    long matchingValue = RandomUtil.randomLong();
    long unmatchingValue = matchingValue + 1;
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    SimpleString otherAddress = RandomUtil.randomSimpleString();
    SimpleString otherQueue = RandomUtil.randomSimpleString();
    session.createQueue(address, queue, null, false);
    session.createQueue(otherAddress, otherQueue, null, false);
    ClientProducer producer = session.createProducer(address);
    // send on queue
    ClientMessage matchingMessage = session.createMessage(false);
    matchingMessage.putLongProperty(key, matchingValue);
    producer.send(matchingMessage);
    ClientMessage unmatchingMessage = session.createMessage(false);
    unmatchingMessage.putLongProperty(key, unmatchingValue);
    producer.send(unmatchingMessage);
    QueueControl queueControl = createManagementControl(address, queue);
    Assert.assertEquals(2, getMessageCount(queueControl));
    // moved matching messages to otherQueue
    int movedMatchedMessagesCount = queueControl.moveMessages(key + " =" + matchingValue, otherQueue.toString());
    Assert.assertEquals(1, movedMatchedMessagesCount);
    Assert.assertEquals(1, getMessageCount(queueControl));
    // consume the unmatched message from queue
    ClientConsumer consumer = session.createConsumer(queue);
    ClientMessage m = consumer.receive(500);
    Assert.assertNotNull(m);
    Assert.assertEquals(unmatchingValue, m.getObjectProperty(key));
    // consume the matched message from otherQueue
    ClientConsumer otherConsumer = session.createConsumer(otherQueue);
    m = otherConsumer.receive(500);
    Assert.assertNotNull(m);
    Assert.assertEquals(matchingValue, m.getObjectProperty(key));
    m.acknowledge();
    consumer.close();
    session.deleteQueue(queue);
    otherConsumer.close();
    session.deleteQueue(otherQueue);
}

86. QueueControlTest#testListDeliveringMessages()

Project: activemq-artemis
File: QueueControlTest.java
@Test
public void testListDeliveringMessages() throws Exception {
    SimpleString address = RandomUtil.randomSimpleString();
    SimpleString queue = RandomUtil.randomSimpleString();
    int intValue = RandomUtil.randomInt();
    session.createQueue(address, queue, null, false);
    Queue srvqueue = server.locateQueue(queue);
    QueueControl queueControl = createManagementControl(address, queue);
    ClientProducer producer = session.createProducer(address);
    ClientMessage message = session.createMessage(false);
    message.putIntProperty(new SimpleString("key"), intValue);
    producer.send(message);
    producer.send(session.createMessage(false));
    ClientConsumer consumer = session.createConsumer(queue);
    session.start();
    ClientMessage msgRec = consumer.receive(5000);
    assertNotNull(msgRec);
    assertEquals(msgRec.getIntProperty("key").intValue(), intValue);
    ClientSessionFactory sf2 = createSessionFactory(locator);
    ClientSession session2 = sf2.createSession(false, true, false);
    ClientConsumer consumer2 = session2.createConsumer(queue);
    session2.start();
    ClientMessage msgRec2 = consumer2.receive(5000);
    assertNotNull(msgRec2);
    assertEquals(2, srvqueue.getDeliveringCount());
    assertEquals(2, srvqueue.getConsumerCount());
    System.out.println(queueControl.listDeliveringMessagesAsJSON());
    Map<String, Map<String, Object>[]> deliveringMap = queueControl.listDeliveringMessages();
    assertEquals(2, deliveringMap.size());
    consumer.close();
    consumer2.close();
    session.deleteQueue(queue);
}

87. ActiveMQServerControlTest#testTotalConsumerCount()

Project: activemq-artemis
File: ActiveMQServerControlTest.java
@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), mbeanServer);
    QueueControl queueControl2 = ManagementControlHelper.createQueueControl(SimpleString.toSimpleString(random2), SimpleString.toSimpleString(random2), mbeanServer);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory csf = createSessionFactory(locator);
    ClientSession session = csf.createSession();
    session.createQueue(random1, random1);
    session.createQueue(random2, random2);
    ClientConsumer consumer1 = session.createConsumer(random1);
    ClientConsumer consumer2 = session.createConsumer(random2);
    assertEquals(2 + (usingCore() ? 1 : 0), serverControl.getTotalConsumerCount());
    assertEquals(1, queueControl1.getConsumerCount());
    assertEquals(1, queueControl2.getConsumerCount());
    consumer1.close();
    consumer2.close();
    session.deleteQueue(random1);
    session.deleteQueue(random2);
    session.close();
    locator.close();
}

88. ActiveMQServerControlTest#testTotalMessagesAcknowledged()

Project: activemq-artemis
File: ActiveMQServerControlTest.java
@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, random1);
    session.createQueue(random2, 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 + (usingCore() ? 1 : 0), serverControl.getTotalMessageCount());
    consumer1.close();
    consumer2.close();
    session.deleteQueue(random1);
    session.deleteQueue(random2);
    session.close();
    locator.close();
}

89. ActiveMQServerControlTest#testTotalMessagesAdded()

Project: activemq-artemis
File: ActiveMQServerControlTest.java
@Test
public void testTotalMessagesAdded() 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, random1);
    session.createQueue(random2, 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.getTotalMessagesAdded());
    assertEquals(0 + (usingCore() ? 1 : 0), serverControl.getTotalMessageCount());
    consumer1.close();
    consumer2.close();
    session.deleteQueue(random1);
    session.deleteQueue(random2);
    session.close();
    locator.close();
}

90. ActiveMQServerControlTest#testCreateAndDestroyBridge()

Project: activemq-artemis
File: ActiveMQServerControlTest.java
@Test
public void testCreateAndDestroyBridge() throws Exception {
    String name = RandomUtil.randomString();
    String sourceAddress = RandomUtil.randomString();
    String sourceQueue = RandomUtil.randomString();
    String targetAddress = RandomUtil.randomString();
    String targetQueue = RandomUtil.randomString();
    ActiveMQServerControl serverControl = createManagementControl();
    checkNoResource(ObjectNameBuilder.DEFAULT.getBridgeObjectName(name));
    assertEquals(0, serverControl.getBridgeNames().length);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory csf = createSessionFactory(locator);
    ClientSession session = csf.createSession();
    session.createQueue(sourceAddress, sourceQueue);
    session.createQueue(targetAddress, targetQueue);
    // forwardingAddress
    serverControl.createBridge(// forwardingAddress
    name, // forwardingAddress
    sourceQueue, // forwardingAddress
    targetAddress, // forwardingAddress
    null, // filterString
    null, // duplicateDetection
    ActiveMQClient.DEFAULT_RETRY_INTERVAL, // duplicateDetection
    ActiveMQClient.DEFAULT_RETRY_INTERVAL_MULTIPLIER, // duplicateDetection
    ActiveMQClient.INITIAL_CONNECT_ATTEMPTS, // duplicateDetection
    ActiveMQClient.DEFAULT_RECONNECT_ATTEMPTS, // duplicateDetection
    false, // confirmationWindowSize
    1, // producerWindowSize
    -1, // liveConnector
    ActiveMQClient.DEFAULT_CLIENT_FAILURE_CHECK_PERIOD, // liveConnector
    connectorConfig.getName(), false, false, null, null);
    checkResource(ObjectNameBuilder.DEFAULT.getBridgeObjectName(name));
    String[] bridgeNames = serverControl.getBridgeNames();
    assertEquals(1, bridgeNames.length);
    assertEquals(name, bridgeNames[0]);
    BridgeControl bridgeControl = ManagementControlHelper.createBridgeControl(name, mbeanServer);
    assertEquals(name, bridgeControl.getName());
    assertTrue(bridgeControl.isStarted());
    // check that a message sent to the sourceAddress is put in the tagetQueue
    ClientProducer producer = session.createProducer(sourceAddress);
    ClientMessage message = session.createMessage(false);
    String text = RandomUtil.randomString();
    message.putStringProperty("prop", text);
    producer.send(message);
    session.start();
    ClientConsumer targetConsumer = session.createConsumer(targetQueue);
    message = targetConsumer.receive(5000);
    assertNotNull(message);
    assertEquals(text, message.getStringProperty("prop"));
    ClientConsumer sourceConsumer = session.createConsumer(sourceQueue);
    assertNull(sourceConsumer.receiveImmediate());
    serverControl.destroyBridge(name);
    checkNoResource(ObjectNameBuilder.DEFAULT.getBridgeObjectName(name));
    assertEquals(0, serverControl.getBridgeNames().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(targetConsumer.receiveImmediate());
    message = sourceConsumer.receive(5000);
    assertNotNull(message);
    assertEquals(text2, message.getStringProperty("prop"));
    sourceConsumer.close();
    targetConsumer.close();
    session.deleteQueue(sourceQueue);
    session.deleteQueue(targetQueue);
    session.close();
    locator.close();
}

91. ActiveMQServerControlTest#testCreateAndDestroyDivert()

Project: activemq-artemis
File: ActiveMQServerControlTest.java
@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));
    assertEquals(0, serverControl.getDivertNames().length);
    serverControl.createDivert(name.toString(), routingName, address, forwardingAddress, true, null, null);
    checkResource(ObjectNameBuilder.DEFAULT.getDivertObjectName(name));
    DivertControl divertControl = ManagementControlHelper.createDivertControl(name.toString(), 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, divertQueue);
    session.createQueue(address, 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));
    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();
}

92. JMSQueueControlTest#testMoveMessagesWithDuplicateIDSetSingleMessage()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testMoveMessagesWithDuplicateIDSetSingleMessage() throws Exception {
    String otherQueueName = RandomUtil.randomString();
    serverManager.createQueue(false, otherQueueName, null, true, otherQueueName);
    ActiveMQDestination otherQueue = (ActiveMQDestination) ActiveMQJMSClient.createQueue(otherQueueName);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true);
    ClientProducer prod1 = session.createProducer(queue.getAddress());
    ClientProducer prod2 = session.createProducer(otherQueue.getAddress());
    ClientMessage msg = session.createMessage(true);
    msg.putStringProperty(org.apache.activemq.artemis.api.core.Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString("dupl-1"));
    prod1.send(msg);
    prod2.send(msg);
    JMSQueueControl queueControl = createManagementControl();
    JMSQueueControl otherQueueControl = ManagementControlHelper.createJMSQueueControl((ActiveMQQueue) otherQueue, mbeanServer);
    Assert.assertEquals(1, getMessageCount(queueControl));
    Assert.assertEquals(1, getMessageCount(otherQueueControl));
    int moved = queueControl.moveMessages(null, otherQueueName, true);
    assertEquals(1, moved);
    assertEquals(0, queueControl.getDeliveringCount());
    session.start();
    ClientConsumer cons1 = session.createConsumer(queue.getAddress());
    assertNull(cons1.receiveImmediate());
    cons1.close();
    ClientConsumer cons2 = session.createConsumer(otherQueue.getAddress());
    msg = cons2.receive(10000);
    assertNotNull(msg);
    msg.acknowledge();
    cons2.close();
    session.close();
    sf.close();
    locator.close();
    Assert.assertEquals(0, getMessageCount(queueControl));
    Assert.assertEquals(0, getMessageCount(otherQueueControl));
    serverManager.destroyQueue(otherQueueName);
}

93. JMSQueueControlTest#testMoveIndividualMessagesWithDuplicateIDSetUsingI()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testMoveIndividualMessagesWithDuplicateIDSetUsingI() throws Exception {
    String otherQueueName = RandomUtil.randomString();
    serverManager.createQueue(false, otherQueueName, null, true, otherQueueName);
    ActiveMQDestination otherQueue = (ActiveMQDestination) ActiveMQJMSClient.createQueue(otherQueueName);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true);
    ClientProducer prod1 = session.createProducer(queue.getAddress());
    ClientProducer prod2 = session.createProducer(otherQueue.getAddress());
    String[] ids = new String[10];
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.putStringProperty(org.apache.activemq.artemis.api.core.Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString("dupl-" + i));
        msg.setUserID(UUIDGenerator.getInstance().generateUUID());
        prod1.send(msg);
        ids[i] = "ID:" + msg.getUserID().toString();
        if (i < 5) {
            msg.setUserID(UUIDGenerator.getInstance().generateUUID());
            prod2.send(msg);
        }
    }
    session.commit();
    JMSQueueControl queueControl = createManagementControl();
    JMSQueueControl otherQueueControl = ManagementControlHelper.createJMSQueueControl((ActiveMQQueue) otherQueue, mbeanServer);
    Assert.assertEquals(10, getMessageCount(queueControl));
    for (int i = 0; i < 10; i++) {
        queueControl.moveMessage(ids[i], otherQueueName, true);
    }
    assertEquals(0, queueControl.getDeliveringCount());
    session.start();
    ClientConsumer cons1 = session.createConsumer(queue.getAddress());
    assertNull(cons1.receiveImmediate());
    cons1.close();
    ClientConsumer cons2 = session.createConsumer(otherQueue.getAddress());
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = cons2.receive(10000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    cons2.close();
    session.close();
    sf.close();
    locator.close();
    Assert.assertEquals(0, getMessageCount(queueControl));
    Assert.assertEquals(0, getMessageCount(otherQueueControl));
    serverManager.destroyQueue(otherQueueName);
}

94. JMSQueueControlTest#testMoveMessagesWithDuplicateIDSet()

Project: activemq-artemis
File: JMSQueueControlTest.java
@Test
public void testMoveMessagesWithDuplicateIDSet() throws Exception {
    String otherQueueName = RandomUtil.randomString();
    serverManager.createQueue(false, otherQueueName, null, true, otherQueueName);
    ActiveMQDestination otherQueue = (ActiveMQDestination) ActiveMQJMSClient.createQueue(otherQueueName);
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true);
    ClientProducer prod1 = session.createProducer(queue.getAddress());
    ClientProducer prod2 = session.createProducer(otherQueue.getAddress());
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = session.createMessage(true);
        msg.putStringProperty(org.apache.activemq.artemis.api.core.Message.HDR_DUPLICATE_DETECTION_ID, new SimpleString("dupl-" + i));
        prod1.send(msg);
        if (i < 5) {
            prod2.send(msg);
        }
    }
    session.commit();
    JMSQueueControl queueControl = createManagementControl();
    JMSQueueControl otherQueueControl = ManagementControlHelper.createJMSQueueControl((ActiveMQQueue) otherQueue, mbeanServer);
    Assert.assertEquals(10, getMessageCount(queueControl));
    int moved = queueControl.moveMessages(null, otherQueueName, true);
    assertEquals(10, moved);
    assertEquals(0, queueControl.getDeliveringCount());
    session.start();
    ClientConsumer cons1 = session.createConsumer(queue.getAddress());
    assertNull(cons1.receiveImmediate());
    cons1.close();
    ClientConsumer cons2 = session.createConsumer(otherQueue.getAddress());
    for (int i = 0; i < 10; i++) {
        ClientMessage msg = cons2.receive(10000);
        assertNotNull(msg);
        msg.acknowledge();
    }
    cons2.close();
    session.close();
    sf.close();
    locator.close();
    Assert.assertEquals(0, getMessageCount(queueControl));
    Assert.assertEquals(0, getMessageCount(otherQueueControl));
    serverManager.destroyQueue(otherQueueName);
}

95. PersistentDivertTest#doTestPersistentDivertRestartBeforeConsume()

Project: activemq-artemis
File: PersistentDivertTest.java
public void doTestPersistentDivertRestartBeforeConsume(final boolean largeMessage) throws Exception {
    final String testAddress = "testAddress";
    final String forwardAddress1 = "forwardAddress1";
    final String forwardAddress2 = "forwardAddress2";
    final String forwardAddress3 = "forwardAddress3";
    DivertConfiguration divertConf1 = new DivertConfiguration().setName("divert1").setRoutingName("divert1").setAddress(testAddress).setForwardingAddress(forwardAddress1);
    DivertConfiguration divertConf2 = new DivertConfiguration().setName("divert2").setRoutingName("divert2").setAddress(testAddress).setForwardingAddress(forwardAddress2);
    DivertConfiguration divertConf3 = new DivertConfiguration().setName("divert3").setRoutingName("divert3").setAddress(testAddress).setForwardingAddress(forwardAddress3);
    Configuration config = createDefaultInVMConfig().addDivertConfiguration(divertConf1).addDivertConfiguration(divertConf2).addDivertConfiguration(divertConf3);
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config));
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true, 0);
    final SimpleString queueName1 = new SimpleString("queue1");
    final SimpleString queueName2 = new SimpleString("queue2");
    final SimpleString queueName3 = new SimpleString("queue3");
    final SimpleString queueName4 = new SimpleString("queue4");
    session.createQueue(new SimpleString(forwardAddress1), queueName1, null, true);
    session.createQueue(new SimpleString(forwardAddress2), queueName2, null, true);
    session.createQueue(new SimpleString(forwardAddress3), queueName3, null, true);
    session.createQueue(new SimpleString(testAddress), queueName4, null, true);
    ClientProducer producer = session.createProducer(new SimpleString(testAddress));
    final int numMessages = 10;
    final SimpleString propKey = new SimpleString("testkey");
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(true);
        message.putIntProperty(propKey, i);
        if (largeMessage) {
            message.setBodyInputStream(ActiveMQTestBase.createFakeLargeStream(minLargeMessageSize));
        }
        producer.send(message);
    }
    session.close();
    sf.close();
    server.stop();
    waitForServerToStop(server);
    server.start();
    ServerLocator locator2 = createInVMNonHALocator().setBlockOnDurableSend(true);
    sf = createSessionFactory(locator2);
    session = sf.createSession(false, true, true);
    session.start();
    ClientConsumer consumer1 = session.createConsumer(queueName1);
    ClientConsumer consumer2 = session.createConsumer(queueName2);
    ClientConsumer consumer3 = session.createConsumer(queueName3);
    ClientConsumer consumer4 = session.createConsumer(queueName4);
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer1.receive(5000);
        Assert.assertNotNull(message);
        if (largeMessage) {
            checkLargeMessage(message);
        }
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer1.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer2.receive(5000);
        Assert.assertNotNull(message);
        if (largeMessage) {
            checkLargeMessage(message);
        }
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer2.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer3.receive(5000);
        Assert.assertNotNull(message);
        if (largeMessage) {
            checkLargeMessage(message);
        }
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer3.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer4.receive(5000);
        Assert.assertNotNull(message);
        if (largeMessage) {
            checkLargeMessage(message);
        }
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer4.receiveImmediate());
    session.close();
    sf.close();
    server.stop();
    waitForServerToStop(server);
    server.start();
    ServerLocator locator3 = createInVMNonHALocator().setBlockOnDurableSend(true);
    sf = createSessionFactory(locator3);
    session = sf.createSession(false, true, true);
    consumer1 = session.createConsumer(queueName1);
    consumer2 = session.createConsumer(queueName2);
    consumer3 = session.createConsumer(queueName3);
    consumer4 = session.createConsumer(queueName4);
    Assert.assertNull(consumer1.receiveImmediate());
    Assert.assertNull(consumer2.receiveImmediate());
    Assert.assertNull(consumer3.receiveImmediate());
    Assert.assertNull(consumer4.receiveImmediate());
}

96. PersistentDivertTest#doTestPersistentDivert()

Project: activemq-artemis
File: PersistentDivertTest.java
public void doTestPersistentDivert(final boolean largeMessage) throws Exception {
    final String testAddress = "testAddress";
    final String forwardAddress1 = "forwardAddress1";
    final String forwardAddress2 = "forwardAddress2";
    final String forwardAddress3 = "forwardAddress3";
    DivertConfiguration divertConf1 = new DivertConfiguration().setName("divert1").setRoutingName("divert1").setAddress(testAddress).setForwardingAddress(forwardAddress1);
    DivertConfiguration divertConf2 = new DivertConfiguration().setName("divert2").setRoutingName("divert2").setAddress(testAddress).setForwardingAddress(forwardAddress2);
    DivertConfiguration divertConf3 = new DivertConfiguration().setName("divert3").setRoutingName("divert3").setAddress(testAddress).setForwardingAddress(forwardAddress3);
    Configuration config = createDefaultInVMConfig().addDivertConfiguration(divertConf1).addDivertConfiguration(divertConf2).addDivertConfiguration(divertConf3);
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config));
    server.start();
    ServerLocator locator = createInVMNonHALocator().setBlockOnAcknowledge(true).setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(true, true, 0);
    final SimpleString queueName1 = new SimpleString("queue1");
    final SimpleString queueName2 = new SimpleString("queue2");
    final SimpleString queueName3 = new SimpleString("queue3");
    final SimpleString queueName4 = new SimpleString("queue4");
    session.createQueue(new SimpleString(forwardAddress1), queueName1, null, true);
    session.createQueue(new SimpleString(forwardAddress2), queueName2, null, true);
    session.createQueue(new SimpleString(forwardAddress3), queueName3, null, true);
    session.createQueue(new SimpleString(testAddress), queueName4, null, true);
    session.start();
    ClientProducer producer = session.createProducer(new SimpleString(testAddress));
    ClientConsumer consumer1 = session.createConsumer(queueName1);
    ClientConsumer consumer2 = session.createConsumer(queueName2);
    ClientConsumer consumer3 = session.createConsumer(queueName3);
    ClientConsumer consumer4 = session.createConsumer(queueName4);
    final int numMessages = 10;
    final SimpleString propKey = new SimpleString("testkey");
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(true);
        if (largeMessage) {
            message.setBodyInputStream(ActiveMQTestBase.createFakeLargeStream(minLargeMessageSize));
        }
        message.putIntProperty(propKey, i);
        producer.send(message);
    }
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer1.receive(5000);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        if (largeMessage) {
            checkLargeMessage(message);
        }
        message.acknowledge();
    }
    Assert.assertNull(consumer1.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer2.receive(5000);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        if (largeMessage) {
            checkLargeMessage(message);
        }
        message.acknowledge();
    }
    Assert.assertNull(consumer2.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer3.receive(5000);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        if (largeMessage) {
            checkLargeMessage(message);
        }
        message.acknowledge();
    }
    Assert.assertNull(consumer3.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer4.receive(5000);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        if (largeMessage) {
            checkLargeMessage(message);
        }
        message.acknowledge();
    }
    Assert.assertNull(consumer4.receiveImmediate());
}

97. DivertTest#testDeployDivertsSameUniqueName()

Project: activemq-artemis
File: DivertTest.java
@Test
public void testDeployDivertsSameUniqueName() throws Exception {
    final String testAddress = "testAddress";
    final String forwardAddress1 = "forwardAddress1";
    final String forwardAddress2 = "forwardAddress2";
    final String forwardAddress3 = "forwardAddress3";
    DivertConfiguration divertConf1 = new DivertConfiguration().setName("divert1").setRoutingName("thename1").setAddress(testAddress).setForwardingAddress(forwardAddress1);
    DivertConfiguration divertConf2 = new DivertConfiguration().setName("divert1").setRoutingName("thename2").setAddress(testAddress).setForwardingAddress(forwardAddress2);
    DivertConfiguration divertConf3 = new DivertConfiguration().setName("divert2").setRoutingName("thename3").setAddress(testAddress).setForwardingAddress(forwardAddress3);
    Configuration config = createDefaultInVMConfig().addDivertConfiguration(divertConf1).addDivertConfiguration(divertConf2).addDivertConfiguration(divertConf3);
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config, false));
    server.start();
    // Only the first and third should be deployed
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    final SimpleString queueName1 = new SimpleString("queue1");
    final SimpleString queueName2 = new SimpleString("queue2");
    final SimpleString queueName3 = new SimpleString("queue3");
    final SimpleString queueName4 = new SimpleString("queue4");
    session.createQueue(new SimpleString(forwardAddress1), queueName1, null, false);
    session.createQueue(new SimpleString(forwardAddress2), queueName2, null, false);
    session.createQueue(new SimpleString(forwardAddress3), queueName3, null, false);
    session.createQueue(new SimpleString(testAddress), queueName4, null, false);
    session.start();
    ClientProducer producer = session.createProducer(new SimpleString(testAddress));
    ClientConsumer consumer1 = session.createConsumer(queueName1);
    ClientConsumer consumer2 = session.createConsumer(queueName2);
    ClientConsumer consumer3 = session.createConsumer(queueName3);
    ClientConsumer consumer4 = session.createConsumer(queueName4);
    final int numMessages = 10;
    final SimpleString propKey = new SimpleString("testkey");
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(false);
        message.putIntProperty(propKey, i);
        producer.send(message);
    }
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer1.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getIntProperty(propKey).intValue());
        message.acknowledge();
    }
    Assert.assertNull(consumer1.receiveImmediate());
    Assert.assertNull(consumer2.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer3.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getIntProperty(propKey).intValue());
        message.acknowledge();
    }
    Assert.assertNull(consumer3.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer4.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getIntProperty(propKey).intValue());
        message.acknowledge();
    }
    Assert.assertNull(consumer4.receiveImmediate());
}

98. DivertTest#testRoundRobinDiverts()

Project: activemq-artemis
File: DivertTest.java
@Test
public void testRoundRobinDiverts() throws Exception {
    final String testAddress = "testAddress";
    final String forwardAddress1 = "forwardAddress1";
    final String forwardAddress2 = "forwardAddress2";
    final String forwardAddress3 = "forwardAddress3";
    DivertConfiguration divertConf1 = new DivertConfiguration().setName("divert1").setRoutingName("thename").setAddress(testAddress).setForwardingAddress(forwardAddress1);
    DivertConfiguration divertConf2 = new DivertConfiguration().setName("divert2").setRoutingName("thename").setAddress(testAddress).setForwardingAddress(forwardAddress2);
    DivertConfiguration divertConf3 = new DivertConfiguration().setName("divert3").setRoutingName("thename").setAddress(testAddress).setForwardingAddress(forwardAddress3);
    Configuration config = createDefaultInVMConfig().addDivertConfiguration(divertConf1).addDivertConfiguration(divertConf2).addDivertConfiguration(divertConf3);
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config, false));
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    final SimpleString queueName1 = new SimpleString("queue1");
    final SimpleString queueName2 = new SimpleString("queue2");
    final SimpleString queueName3 = new SimpleString("queue3");
    final SimpleString queueName4 = new SimpleString("queue4");
    session.createQueue(new SimpleString(forwardAddress1), queueName1, null, false);
    session.createQueue(new SimpleString(forwardAddress2), queueName2, null, false);
    session.createQueue(new SimpleString(forwardAddress3), queueName3, null, false);
    session.createQueue(new SimpleString(testAddress), queueName4, null, false);
    session.start();
    ClientProducer producer = session.createProducer(new SimpleString(testAddress));
    ClientConsumer consumer1 = session.createConsumer(queueName1);
    ClientConsumer consumer2 = session.createConsumer(queueName2);
    ClientConsumer consumer3 = session.createConsumer(queueName3);
    ClientConsumer consumer4 = session.createConsumer(queueName4);
    final int numMessages = 10;
    final SimpleString propKey = new SimpleString("testkey");
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(false);
        message.putIntProperty(propKey, i);
        producer.send(message);
    }
    for (int i = 0; i < numMessages; ) {
        ClientMessage message = consumer1.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
        i++;
        if (i == numMessages) {
            break;
        }
        message = consumer2.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
        i++;
        if (i == numMessages) {
            break;
        }
        message = consumer3.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
        i++;
    }
    Assert.assertNull(consumer1.receiveImmediate());
    Assert.assertNull(consumer2.receiveImmediate());
    Assert.assertNull(consumer3.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer4.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer4.receiveImmediate());
}

99. DivertTest#testSingleExclusiveNonMatchingAndNonExclusiveDiverts()

Project: activemq-artemis
File: DivertTest.java
// If no exclusive diverts match then non exclusive ones should be called
@Test
public void testSingleExclusiveNonMatchingAndNonExclusiveDiverts() throws Exception {
    final String testAddress = "testAddress";
    final String forwardAddress1 = "forwardAddress1";
    final String forwardAddress2 = "forwardAddress2";
    final String forwardAddress3 = "forwardAddress3";
    final String filter = "animal='antelope'";
    DivertConfiguration divertConf1 = new DivertConfiguration().setName("divert1").setRoutingName("divert1").setAddress(testAddress).setForwardingAddress(forwardAddress1).setExclusive(true).setFilterString(filter);
    DivertConfiguration divertConf2 = new DivertConfiguration().setName("divert2").setRoutingName("divert2").setAddress(testAddress).setForwardingAddress(forwardAddress2);
    DivertConfiguration divertConf3 = new DivertConfiguration().setName("divert3").setRoutingName("divert3").setAddress(testAddress).setForwardingAddress(forwardAddress3);
    Configuration config = createDefaultInVMConfig().addDivertConfiguration(divertConf1).addDivertConfiguration(divertConf2).addDivertConfiguration(divertConf3);
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config, false));
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    final SimpleString queueName1 = new SimpleString("queue1");
    final SimpleString queueName2 = new SimpleString("queue2");
    final SimpleString queueName3 = new SimpleString("queue3");
    final SimpleString queueName4 = new SimpleString("queue4");
    session.createQueue(new SimpleString(forwardAddress1), queueName1, null, false);
    session.createQueue(new SimpleString(forwardAddress2), queueName2, null, false);
    session.createQueue(new SimpleString(forwardAddress3), queueName3, null, false);
    session.createQueue(new SimpleString(testAddress), queueName4, null, false);
    session.start();
    ClientProducer producer = session.createProducer(new SimpleString(testAddress));
    ClientConsumer consumer1 = session.createConsumer(queueName1);
    ClientConsumer consumer2 = session.createConsumer(queueName2);
    ClientConsumer consumer3 = session.createConsumer(queueName3);
    ClientConsumer consumer4 = session.createConsumer(queueName4);
    final int numMessages = 10;
    final SimpleString propKey = new SimpleString("testkey");
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(false);
        message.putStringProperty(new SimpleString("animal"), new SimpleString("giraffe"));
        message.putIntProperty(propKey, i);
        producer.send(message);
    }
    // for (int i = 0; i < numMessages; i++)
    // {
    // ClientMessage message = consumer1.receive(200);
    //
    // assertNotNull(message);
    //
    // assertEquals((Integer)i, (Integer)message.getProperty(propKey));
    //
    // message.acknowledge();
    // }
    Assert.assertNull(consumer1.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer2.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer2.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer3.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer3.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer4.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer4.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(false);
        message.putStringProperty(new SimpleString("animal"), new SimpleString("antelope"));
        message.putIntProperty(propKey, i);
        producer.send(message);
    }
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer1.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getObjectProperty(propKey));
        message.acknowledge();
    }
    Assert.assertNull(consumer1.receiveImmediate());
    Assert.assertNull(consumer2.receiveImmediate());
    Assert.assertNull(consumer3.receiveImmediate());
    Assert.assertNull(consumer4.receiveImmediate());
}

100. DivertTest#testMixExclusiveAndNonExclusiveDiverts()

Project: activemq-artemis
File: DivertTest.java
@Test
public void testMixExclusiveAndNonExclusiveDiverts() throws Exception {
    final String testAddress = "testAddress";
    final String forwardAddress1 = "forwardAddress1";
    final String forwardAddress2 = "forwardAddress2";
    final String forwardAddress3 = "forwardAddress3";
    DivertConfiguration divertConf1 = new DivertConfiguration().setName("divert1").setRoutingName("divert1").setAddress(testAddress).setForwardingAddress(forwardAddress1).setExclusive(true);
    DivertConfiguration divertConf2 = new DivertConfiguration().setName("divert2").setRoutingName("divert2").setAddress(testAddress).setForwardingAddress(forwardAddress2).setExclusive(true);
    DivertConfiguration divertConf3 = new DivertConfiguration().setName("divert3").setRoutingName("divert3").setAddress(testAddress).setForwardingAddress(forwardAddress3);
    Configuration config = createDefaultInVMConfig().addDivertConfiguration(divertConf1).addDivertConfiguration(divertConf2).addDivertConfiguration(divertConf3);
    ActiveMQServer server = addServer(ActiveMQServers.newActiveMQServer(config, false));
    server.start();
    ServerLocator locator = createInVMNonHALocator();
    ClientSessionFactory sf = createSessionFactory(locator);
    ClientSession session = sf.createSession(false, true, true);
    final SimpleString queueName1 = new SimpleString("queue1");
    final SimpleString queueName2 = new SimpleString("queue2");
    final SimpleString queueName3 = new SimpleString("queue3");
    final SimpleString queueName4 = new SimpleString("queue4");
    session.createQueue(new SimpleString(forwardAddress1), queueName1, null, false);
    session.createQueue(new SimpleString(forwardAddress2), queueName2, null, false);
    session.createQueue(new SimpleString(forwardAddress3), queueName3, null, false);
    session.createQueue(new SimpleString(testAddress), queueName4, null, false);
    session.start();
    ClientProducer producer = session.createProducer(new SimpleString(testAddress));
    ClientConsumer consumer1 = session.createConsumer(queueName1);
    ClientConsumer consumer2 = session.createConsumer(queueName2);
    ClientConsumer consumer3 = session.createConsumer(queueName3);
    ClientConsumer consumer4 = session.createConsumer(queueName4);
    final int numMessages = 10;
    final SimpleString propKey = new SimpleString("testkey");
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = session.createMessage(false);
        message.putIntProperty(propKey, i);
        producer.send(message);
    }
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer1.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getIntProperty(propKey).intValue());
        message.acknowledge();
    }
    Assert.assertNull(consumer1.receiveImmediate());
    for (int i = 0; i < numMessages; i++) {
        ClientMessage message = consumer2.receive(DivertTest.TIMEOUT);
        Assert.assertNotNull(message);
        Assert.assertEquals(i, message.getIntProperty(propKey).intValue());
        message.acknowledge();
    }
    Assert.assertNull(consumer2.receiveImmediate());
    Assert.assertNull(consumer3.receiveImmediate());
    Assert.assertNull(consumer4.receiveImmediate());
}