/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.activemq.artemis.jms.tests.selector;
import javax.jms.Connection;
import javax.jms.ConnectionFactory;
import javax.jms.DeliveryMode;
import javax.jms.Message;
import javax.jms.MessageConsumer;
import javax.jms.MessageProducer;
import javax.jms.Session;
import javax.jms.TextMessage;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import org.apache.activemq.artemis.jms.client.ActiveMQConnectionFactory;
import org.apache.activemq.artemis.jms.tests.ActiveMQServerTestCase;
import org.apache.activemq.artemis.jms.tests.util.ProxyAssertSupport;
import org.apache.activemq.artemis.tests.util.ActiveMQTestBase;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
public class SelectorTest extends ActiveMQServerTestCase {
/**
* Test case for http://jira.jboss.org/jira/browse/JBMESSAGING-105
* <br>
* Two Messages are sent to a queue. There is one receiver on the queue. The receiver only
* receives one of the messages due to a message selector only matching one of them. The receiver
* is then closed. A new receiver is now attached to the queue. Redelivery of the remaining
* message is now attempted. The message should be redelivered.
*/
@Test
public void testSelectiveClosingConsumer() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = session.createProducer(queue1);
prod.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
String selector = "color = 'red'";
MessageConsumer redConsumer = session.createConsumer(queue1, selector);
conn.start();
Message redMessage = session.createMessage();
redMessage.setStringProperty("color", "red");
Message blueMessage = session.createMessage();
blueMessage.setStringProperty("color", "blue");
prod.send(redMessage);
prod.send(blueMessage);
log.info("sent message");
Message rec = redConsumer.receive();
ProxyAssertSupport.assertEquals(redMessage.getJMSMessageID(), rec.getJMSMessageID());
ProxyAssertSupport.assertEquals("red", rec.getStringProperty("color"));
ProxyAssertSupport.assertNull(redConsumer.receive(3000));
redConsumer.close();
log.info("closed first consumer");
MessageConsumer universalConsumer = session.createConsumer(queue1);
rec = universalConsumer.receive(2000);
ProxyAssertSupport.assertEquals(rec.getJMSMessageID(), blueMessage.getJMSMessageID());
ProxyAssertSupport.assertEquals("blue", rec.getStringProperty("color"));
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testManyTopic() throws Exception {
String selector1 = "beatle = 'john'";
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageConsumer cons1 = sess.createConsumer(ActiveMQServerTestCase.topic1, selector1);
MessageProducer prod = sess.createProducer(ActiveMQServerTestCase.topic1);
for (int j = 0; j < 100; j++) {
Message m = sess.createMessage();
m.setStringProperty("beatle", "john");
prod.send(m);
m = sess.createMessage();
m.setStringProperty("beatle", "kermit the frog");
prod.send(m);
}
for (int j = 0; j < 100; j++) {
Message m = cons1.receive(1000);
ProxyAssertSupport.assertNotNull(m);
}
Thread.sleep(500);
Message m = cons1.receiveNoWait();
ProxyAssertSupport.assertNull(m);
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testManyQueue() throws Exception {
String selector1 = "beatle = 'john'";
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageConsumer cons1 = sess.createConsumer(queue1, selector1);
MessageProducer prod = sess.createProducer(queue1);
for (int j = 0; j < 100; j++) {
Message m = sess.createMessage();
m.setStringProperty("beatle", "john");
m.setIntProperty("wibble", j);
prod.send(m);
m = sess.createMessage();
m.setStringProperty("beatle", "kermit the frog");
m.setIntProperty("wibble", j);
prod.send(m);
}
for (int j = 0; j < 100; j++) {
Message m = cons1.receive(1000);
ProxyAssertSupport.assertNotNull(m);
Assert.assertEquals(j, m.getIntProperty("wibble"));
ProxyAssertSupport.assertEquals("john", m.getStringProperty("beatle"));
log.info("Got message " + j);
}
Message m = cons1.receiveNoWait();
ProxyAssertSupport.assertNull(m);
String selector2 = "beatle = 'kermit the frog'";
MessageConsumer cons2 = sess.createConsumer(queue1, selector2);
for (int j = 0; j < 100; j++) {
m = cons2.receive(1000);
ProxyAssertSupport.assertNotNull(m);
Assert.assertEquals(j, m.getIntProperty("wibble"));
ProxyAssertSupport.assertEquals("kermit the frog", m.getStringProperty("beatle"));
}
// m = cons2.receiveNoWait();
//
// if (m != null)
// {
// log.info("got " + m.getStringProperty("beatle") + " j: " + m.getIntProperty("wibble"));
// }
//ProxyAssertSupport.assertNull(m);
} finally {
if (conn != null) {
conn.close();
}
}
}
// http://jira.jboss.org/jira/browse/JBMESSAGING-775
@Test
public void testManyQueueWithExpired() throws Exception {
String selector1 = "beatle = 'john'";
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
int NUM_MESSAGES = 2;
MessageProducer prod = sess.createProducer(queue1);
for (int j = 0; j < NUM_MESSAGES; j++) {
Message m = sess.createMessage();
m.setStringProperty("beatle", "john");
prod.setTimeToLive(0);
prod.send(m);
m = sess.createMessage();
m.setStringProperty("beatle", "john");
prod.setTimeToLive(1);
prod.send(m);
m = sess.createMessage();
m.setStringProperty("beatle", "kermit the frog");
prod.setTimeToLive(0);
prod.send(m);
m = sess.createMessage();
m.setStringProperty("beatle", "kermit the frog");
m.setJMSExpiration(System.currentTimeMillis());
prod.setTimeToLive(1);
prod.send(m);
}
MessageConsumer cons1 = sess.createConsumer(queue1, selector1);
for (int j = 0; j < NUM_MESSAGES; j++) {
Message m = cons1.receive(1000);
ProxyAssertSupport.assertNotNull(m);
ProxyAssertSupport.assertEquals("john", m.getStringProperty("beatle"));
}
Message m = cons1.receiveNoWait();
ProxyAssertSupport.assertNull(m);
String selector2 = "beatle = 'kermit the frog'";
MessageConsumer cons2 = sess.createConsumer(queue1, selector2);
for (int j = 0; j < NUM_MESSAGES; j++) {
m = cons2.receive(1000);
ProxyAssertSupport.assertNotNull(m);
ProxyAssertSupport.assertEquals("kermit the frog", m.getStringProperty("beatle"));
}
m = cons1.receiveNoWait();
ProxyAssertSupport.assertNull(m);
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testManyRedeliveriesTopic() throws Exception {
String selector1 = "beatle = 'john'";
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
for (int i = 0; i < 5; i++) {
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageConsumer cons1 = sess.createConsumer(ActiveMQServerTestCase.topic1, selector1);
MessageProducer prod = sess.createProducer(ActiveMQServerTestCase.topic1);
for (int j = 0; j < 10; j++) {
Message m = sess.createMessage();
m.setStringProperty("beatle", "john");
prod.send(m);
m = sess.createMessage();
m.setStringProperty("beatle", "kermit the frog");
prod.send(m);
}
for (int j = 0; j < 10; j++) {
Message m = cons1.receive(1000);
ProxyAssertSupport.assertNotNull(m);
}
Message m = cons1.receiveNoWait();
ProxyAssertSupport.assertNull(m);
sess.close();
}
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testManyRedeliveriesQueue() throws Exception {
String selector1 = "beatle = 'john'";
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
for (int i = 0; i < 5; i++) {
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageConsumer cons1 = sess.createConsumer(queue1, selector1);
MessageProducer prod = sess.createProducer(queue1);
for (int j = 0; j < 10; j++) {
TextMessage m = sess.createTextMessage("message-a-" + j);
m.setStringProperty("beatle", "john");
prod.send(m);
m = sess.createTextMessage("messag-b-" + j);
m.setStringProperty("beatle", "kermit the frog");
prod.send(m);
}
for (int j = 0; j < 10; j++) {
Message m = cons1.receive(1000);
ProxyAssertSupport.assertNotNull(m);
}
Message m = cons1.receiveNoWait();
ProxyAssertSupport.assertNull(m);
sess.close();
}
} finally {
if (conn != null) {
conn.close();
}
removeAllMessages(queue1.getQueueName(), true);
}
}
@Test
public void testWithSelector() throws Exception {
String selector1 = "beatle = 'john'";
String selector2 = "beatle = 'paul'";
String selector3 = "beatle = 'george'";
String selector4 = "beatle = 'ringo'";
String selector5 = "beatle = 'jesus'";
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageConsumer cons1 = sess.createConsumer(ActiveMQServerTestCase.topic1, selector1);
MessageConsumer cons2 = sess.createConsumer(ActiveMQServerTestCase.topic1, selector2);
MessageConsumer cons3 = sess.createConsumer(ActiveMQServerTestCase.topic1, selector3);
MessageConsumer cons4 = sess.createConsumer(ActiveMQServerTestCase.topic1, selector4);
MessageConsumer cons5 = sess.createConsumer(ActiveMQServerTestCase.topic1, selector5);
Message m1 = sess.createMessage();
m1.setStringProperty("beatle", "john");
Message m2 = sess.createMessage();
m2.setStringProperty("beatle", "paul");
Message m3 = sess.createMessage();
m3.setStringProperty("beatle", "george");
Message m4 = sess.createMessage();
m4.setStringProperty("beatle", "ringo");
Message m5 = sess.createMessage();
m5.setStringProperty("beatle", "jesus");
MessageProducer prod = sess.createProducer(ActiveMQServerTestCase.topic1);
prod.send(m1);
prod.send(m2);
prod.send(m3);
prod.send(m4);
prod.send(m5);
Message r1 = cons1.receive(500);
ProxyAssertSupport.assertNotNull(r1);
Message n = cons1.receive(500);
ProxyAssertSupport.assertNull(n);
Message r2 = cons2.receive(500);
ProxyAssertSupport.assertNotNull(r2);
n = cons2.receive(500);
ProxyAssertSupport.assertNull(n);
Message r3 = cons3.receive(500);
ProxyAssertSupport.assertNotNull(r3);
n = cons3.receive(500);
ProxyAssertSupport.assertNull(n);
Message r4 = cons4.receive(500);
ProxyAssertSupport.assertNotNull(r4);
n = cons4.receive(500);
ProxyAssertSupport.assertNull(n);
Message r5 = cons5.receive(500);
ProxyAssertSupport.assertNotNull(r5);
n = cons5.receive(500);
ProxyAssertSupport.assertNull(n);
ProxyAssertSupport.assertEquals("john", r1.getStringProperty("beatle"));
ProxyAssertSupport.assertEquals("paul", r2.getStringProperty("beatle"));
ProxyAssertSupport.assertEquals("george", r3.getStringProperty("beatle"));
ProxyAssertSupport.assertEquals("ringo", r4.getStringProperty("beatle"));
ProxyAssertSupport.assertEquals("jesus", r5.getStringProperty("beatle"));
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testManyConsumersWithDifferentSelectors() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
Session sess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer p = sess.createProducer(queue1);
Session cs = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
final MessageConsumer c = cs.createConsumer(queue1, "weight = 1");
Session cs2 = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
final MessageConsumer c2 = cs2.createConsumer(queue1, "weight = 2");
for (int i = 0; i < 10; i++) {
Message m = sess.createTextMessage("message" + i);
m.setIntProperty("weight", i % 2 + 1);
p.send(m);
}
conn.start();
final List<Message> received = new ArrayList<>();
final List<Message> received2 = new ArrayList<>();
final CountDownLatch latch = new CountDownLatch(1);
final CountDownLatch latch2 = new CountDownLatch(1);
new Thread(new Runnable() {
@Override
public void run() {
try {
while (true) {
Message m = c.receive(1000);
if (m != null) {
received.add(m);
} else {
latch.countDown();
return;
}
}
} catch (Exception e) {
log.error("receive failed", e);
}
}
}, "consumer thread 1").start();
new Thread(new Runnable() {
@Override
public void run() {
try {
while (true) {
Message m = c2.receive(1000);
if (m != null) {
received2.add(m);
} else {
latch2.countDown();
return;
}
}
} catch (Exception e) {
log.error("receive failed", e);
}
}
}, "consumer thread 2").start();
ActiveMQTestBase.waitForLatch(latch);
ActiveMQTestBase.waitForLatch(latch2);
ProxyAssertSupport.assertEquals(5, received.size());
for (Message m : received) {
int value = m.getIntProperty("weight");
ProxyAssertSupport.assertEquals(value, 1);
}
ProxyAssertSupport.assertEquals(5, received2.size());
for (Message m : received2) {
int value = m.getIntProperty("weight");
ProxyAssertSupport.assertEquals(value, 2);
}
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testDeliveryModeOnSelector() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prodNonPersistent = session.createProducer(queue1);
prodNonPersistent.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
MessageProducer prodPersistent = session.createProducer(queue1);
prodPersistent.setDeliveryMode(DeliveryMode.PERSISTENT);
String selector = "JMSDeliveryMode = 'PERSISTENT'";
MessageConsumer persistentConsumer = session.createConsumer(queue1, selector);
conn.start();
TextMessage msg = session.createTextMessage("NonPersistent");
prodNonPersistent.send(msg);
msg = session.createTextMessage("Persistent");
prodPersistent.send(msg);
msg = (TextMessage) persistentConsumer.receive(2000);
ProxyAssertSupport.assertNotNull(msg);
ProxyAssertSupport.assertEquals(DeliveryMode.PERSISTENT, msg.getJMSDeliveryMode());
ProxyAssertSupport.assertEquals("Persistent", msg.getText());
ProxyAssertSupport.assertNull(persistentConsumer.receive(1000));
persistentConsumer.close();
MessageConsumer genericConsumer = session.createConsumer(queue1);
msg = (TextMessage) genericConsumer.receive(1000);
ProxyAssertSupport.assertNotNull(msg);
ProxyAssertSupport.assertEquals("NonPersistent", msg.getText());
ProxyAssertSupport.assertEquals(DeliveryMode.NON_PERSISTENT, msg.getJMSDeliveryMode());
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testJMSMessageIDOnSelector() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = session.createProducer(queue1);
TextMessage msg1 = session.createTextMessage("msg1");
prod.send(msg1);
TextMessage msg2 = session.createTextMessage("msg2");
prod.send(msg2);
String selector = "JMSMessageID = '" + msg2.getJMSMessageID() + "'";
MessageConsumer cons = session.createConsumer(queue1, selector);
conn.start();
TextMessage rec = (TextMessage) cons.receive(10000);
assertNotNull(rec);
Assert.assertEquals("msg2", rec.getText());
assertNull(cons.receiveNoWait());
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testJMSPriorityOnSelector() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = session.createProducer(queue1);
TextMessage msg1 = session.createTextMessage("msg1");
prod.send(msg1, DeliveryMode.NON_PERSISTENT, 8, 0);
TextMessage msg2 = session.createTextMessage("msg2");
prod.send(msg2, DeliveryMode.NON_PERSISTENT, 2, 0);
String selector = "JMSPriority = 2";
MessageConsumer cons = session.createConsumer(queue1, selector);
conn.start();
TextMessage rec = (TextMessage) cons.receive(10000);
assertNotNull(rec);
Assert.assertEquals("msg2", rec.getText());
assertNull(cons.receiveNoWait());
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testJMSTimestampOnSelector() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = session.createProducer(queue1);
TextMessage msg1 = session.createTextMessage("msg1");
prod.send(msg1);
Thread.sleep(2);
TextMessage msg2 = session.createTextMessage("msg2");
prod.send(msg2);
String selector = "JMSTimestamp = " + msg2.getJMSTimestamp();
MessageConsumer cons = session.createConsumer(queue1, selector);
conn.start();
TextMessage rec = (TextMessage) cons.receive(10000);
assertNotNull(rec);
Assert.assertEquals("msg2", rec.getText());
assertNull(cons.receiveNoWait());
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testJMSExpirationOnSelector() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = session.createProducer(queue1);
TextMessage msg1 = session.createTextMessage("msg1");
prod.send(msg1);
prod.setTimeToLive(100000);
TextMessage msg2 = session.createTextMessage("msg2");
prod.send(msg2);
long expire = msg2.getJMSExpiration();
String selector = "JMSExpiration = " + expire;
MessageConsumer cons = session.createConsumer(queue1, selector);
conn.start();
TextMessage rec = (TextMessage) cons.receive(10000);
assertNotNull(rec);
Assert.assertEquals("msg2", rec.getText());
assertNull(cons.receiveNoWait());
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testJMSTypeOnSelector() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = session.createProducer(queue1);
TextMessage msg1 = session.createTextMessage("msg1");
msg1.setJMSType("type1");
prod.send(msg1);
TextMessage msg2 = session.createTextMessage("msg2");
msg2.setJMSType("type2");
prod.send(msg2);
String selector = "JMSType = 'type2'";
MessageConsumer cons = session.createConsumer(queue1, selector);
conn.start();
TextMessage rec = (TextMessage) cons.receive(10000);
assertNotNull(rec);
Assert.assertEquals("msg2", rec.getText());
assertNull(cons.receiveNoWait());
} finally {
if (conn != null) {
conn.close();
}
}
}
@Test
public void testJMSCorrelationIDOnSelector() throws Exception {
Connection conn = null;
try {
conn = getConnectionFactory().createConnection();
conn.start();
Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
MessageProducer prod = session.createProducer(queue1);
TextMessage msg1 = session.createTextMessage("msg1");
msg1.setJMSCorrelationID("cid1");
prod.send(msg1);
TextMessage msg2 = session.createTextMessage("msg2");
msg2.setJMSCorrelationID("cid2");
prod.send(msg2);
String selector = "JMSCorrelationID = 'cid2'";
MessageConsumer cons = session.createConsumer(queue1, selector);
conn.start();
TextMessage rec = (TextMessage) cons.receive(10000);
assertNotNull(rec);
Assert.assertEquals("msg2", rec.getText());
assertNull(cons.receiveNoWait());
} finally {
if (conn != null) {
conn.close();
}
}
}
// Test case proposed by a customer on this user forum:
// http://community.jboss.org/thread/153426?tstart=0
// This test needs to be moved away
public void disabled_testMultipleConsumers() throws Exception {
Connection conn = null;
try {
ConnectionFactory factory = getConnectionFactory();
ActiveMQConnectionFactory hcf = (ActiveMQConnectionFactory) factory;
hcf.setConsumerWindowSize(0);
conn = hcf.createConnection();
conn.setClientID("SomeClientID");
conn.start();
Session session = conn.createSession(false, Session.CLIENT_ACKNOWLEDGE);
MessageProducer msgProducer = session.createProducer(queue1);
TextMessage tm;
/* Publish messages */
tm = session.createTextMessage();
tm.setText("1");
tm.setStringProperty("PROP1", "VALUE1");
msgProducer.send(tm);
System.out.println("Sent message with id [" + tm.getJMSMessageID() + "]");
tm = session.createTextMessage();
tm.setText("2");
tm.setStringProperty("PROP1", "VALUE1");
msgProducer.send(tm);
System.out.println("Sent message with id [" + tm.getJMSMessageID() + "]");
tm = session.createTextMessage();
tm.setText("3");
tm.setStringProperty("PROP2", "VALUE2");
msgProducer.send(tm);
System.out.println("Sent message with id [" + tm.getJMSMessageID() + "]");
tm = session.createTextMessage();
tm.setText("4");
tm.setStringProperty("PROP2", "VALUE2");
msgProducer.send(tm);
System.out.println("Sent message with id [" + tm.getJMSMessageID() + "]");
tm = session.createTextMessage();
tm.setText("5");
tm.setStringProperty("PROP1", "VALUE1");
msgProducer.send(tm);
System.out.println("Sent message with id [" + tm.getJMSMessageID() + "]");
tm = session.createTextMessage();
tm.setText("6");
tm.setStringProperty("PROP1", "VALUE1");
tm.setStringProperty("PROP2", "VALUE2");
msgProducer.send(tm);
System.out.println("Sent message with id [" + tm.getJMSMessageID() + "]");
msgProducer.close();
msgProducer = null;
MessageConsumer msgConsumer = session.createConsumer(queue1, "PROP2 = 'VALUE2'");
tm = (TextMessage) msgConsumer.receive(5000);
assertNotNull(tm);
Assert.assertEquals("3", tm.getText());
Assert.assertEquals("VALUE2", tm.getStringProperty("PROP2"));
tm.acknowledge();
conn.close(); // this should close the consumer, producer and session associated with the connection
// Reopen the connection and consumer
conn = getConnectionFactory().createConnection();
conn.start();
session = conn.createSession(false, Session.CLIENT_ACKNOWLEDGE);
msgConsumer = session.createConsumer(queue1);
tm = (TextMessage) msgConsumer.receive(5000);
Assert.assertEquals("1", tm.getText());
Assert.assertEquals("VALUE1", tm.getStringProperty("PROP1"));
tm = (TextMessage) msgConsumer.receive(5000);
Assert.assertEquals("2", tm.getText());
Assert.assertEquals("VALUE1", tm.getStringProperty("PROP1"));
tm = (TextMessage) msgConsumer.receive(5000);
Assert.assertEquals("4", tm.getText());
Assert.assertEquals("VALUE2", tm.getStringProperty("PROP2"));
tm = (TextMessage) msgConsumer.receive(5000);
Assert.assertEquals("5", tm.getText());
Assert.assertEquals("VALUE1", tm.getStringProperty("PROP1"));
tm = (TextMessage) msgConsumer.receive(5000);
Assert.assertEquals("6", tm.getText());
Assert.assertEquals("VALUE1", tm.getStringProperty("PROP1"));
Assert.assertEquals("VALUE2", tm.getStringProperty("PROP2"));
tm.acknowledge();
} finally {
if (conn != null) {
conn.close();
}
}
}
// Package protected ---------------------------------------------
// Protected -----------------------------------------------------
// Private -------------------------------------------------------
// Inner classes -------------------------------------------------
}