You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@qpid.apache.org by kw...@apache.org on 2017/12/21 17:27:50 UTC
[7/7] qpid-broker-j git commit: QPID-6933: [System Tests] Move
MessageGroupTest to new suite
QPID-6933: [System Tests] Move MessageGroupTest to new suite
Project: http://git-wip-us.apache.org/repos/asf/qpid-broker-j/repo
Commit: http://git-wip-us.apache.org/repos/asf/qpid-broker-j/commit/b6186672
Tree: http://git-wip-us.apache.org/repos/asf/qpid-broker-j/tree/b6186672
Diff: http://git-wip-us.apache.org/repos/asf/qpid-broker-j/diff/b6186672
Branch: refs/heads/master
Commit: b618667270dcdf2880ff02b0a21aaa6ecab37064
Parents: bd640ff
Author: Keith Wall <kw...@apache.org>
Authored: Thu Dec 21 17:27:13 2017 +0000
Committer: Keith Wall <kw...@apache.org>
Committed: Thu Dec 21 17:27:13 2017 +0000
----------------------------------------------------------------------
.../jms_1_1/messagegroup/MessageGroupTest.java | 663 ++++++++++++++++++
.../server/queue/MessageGroupQueueTest.java | 686 -------------------
test-profiles/CPPExcludes | 10 -
3 files changed, 663 insertions(+), 696 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/qpid-broker-j/blob/b6186672/systests/qpid-systests-jms_1.1/src/test/java/org/apache/qpid/systests/jms_1_1/messagegroup/MessageGroupTest.java
----------------------------------------------------------------------
diff --git a/systests/qpid-systests-jms_1.1/src/test/java/org/apache/qpid/systests/jms_1_1/messagegroup/MessageGroupTest.java b/systests/qpid-systests-jms_1.1/src/test/java/org/apache/qpid/systests/jms_1_1/messagegroup/MessageGroupTest.java
new file mode 100644
index 0000000..cf7bff6
--- /dev/null
+++ b/systests/qpid-systests-jms_1.1/src/test/java/org/apache/qpid/systests/jms_1_1/messagegroup/MessageGroupTest.java
@@ -0,0 +1,663 @@
+/*
+ *
+ * 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.qpid.systests.jms_1_1.messagegroup;
+
+import static javax.jms.Session.AUTO_ACKNOWLEDGE;
+import static javax.jms.Session.CLIENT_ACKNOWLEDGE;
+import static javax.jms.Session.SESSION_TRANSACTED;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import javax.jms.Connection;
+import javax.jms.Destination;
+import javax.jms.JMSException;
+import javax.jms.Message;
+import javax.jms.MessageConsumer;
+import javax.jms.MessageListener;
+import javax.jms.MessageProducer;
+import javax.jms.Session;
+
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import org.apache.qpid.server.model.ConfiguredObject;
+import org.apache.qpid.server.queue.MessageGroupType;
+import org.apache.qpid.systests.JmsTestBase;
+
+public class MessageGroupTest extends JmsTestBase
+{
+ private static final Logger LOGGER = LoggerFactory.getLogger(MessageGroupTest.class);
+
+ @Test
+ public void simpleGroupAssignment() throws Exception
+ {
+ simpleGroupAssignment(false, false);
+ }
+
+ @Test
+ public void sharedGroupSimpleGroupAssignment() throws Exception
+ {
+ simpleGroupAssignment(true, false);
+ }
+
+ @Test
+ public void simpleGroupAssignmentWithJMSXGroupID() throws Exception
+ {
+ simpleGroupAssignment(false, true);
+ }
+
+ @Test
+ public void sharedGroupSimpleGroupAssignmentWithJMSXGroupID() throws Exception
+ {
+ simpleGroupAssignment(true, true);
+ }
+
+ /**
+ * Pre populate the queue with messages with groups as follows
+ *
+ * ONE
+ * TWO
+ * ONE
+ * TWO
+ *
+ * Create two consumers with prefetch of 1, the first consumer should then be assigned group ONE, the second
+ * consumer assigned group TWO if they are started in sequence.
+ *
+ * Thus doing
+ *
+ * c1 <--- (ONE)
+ * c2 <--- (TWO)
+ * c2 ack --->
+ *
+ * c2 should now be able to receive a second message from group TWO (skipping over the message from group ONE)
+ *
+ * i.e.
+ *
+ * c2 <--- (TWO)
+ * c2 ack --->
+ * c1 <--- (ONE)
+ * c1 ack --->
+ *
+ */
+ private void simpleGroupAssignment(boolean sharedGroups, final boolean useDefaultGroup) throws Exception
+ {
+ final String groupKey = getGroupKey(useDefaultGroup);
+ String queueName = getTestName();
+ Destination queue = createQueue(queueName, sharedGroups, useDefaultGroup);
+
+ final Connection producerConnection = getConnection();
+ try
+ {
+ producerConnection.start();
+ final Session producerSession = producerConnection.createSession(true, SESSION_TRANSACTED);
+ final MessageProducer producer = producerSession.createProducer(queue);
+
+ String[] groups = { "ONE", "TWO"};
+
+ for (int msg = 0; msg < 4; msg++)
+ {
+ producer.send(createMessage(producerSession, msg, groups[msg % groups.length], useDefaultGroup));
+ }
+ producerSession.commit();
+ }
+ finally
+ {
+ producerConnection.close();
+ }
+
+ final Connection consumerConnection = getConnectionBuilder().setPrefetch(0).build();
+ try
+ {
+ Session cs1 = consumerConnection.createSession(false, CLIENT_ACKNOWLEDGE);
+ Session cs2 = consumerConnection.createSession(false, CLIENT_ACKNOWLEDGE);
+
+ MessageConsumer consumer1 = cs1.createConsumer(queue);
+ MessageConsumer consumer2 = cs2.createConsumer(queue);
+
+ consumerConnection.start();
+ Message cs1Received = consumer1.receive(getReceiveTimeout());
+ assertNotNull("Consumer 1 should have received first message", cs1Received);
+
+ Message cs2Received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received first message", cs2Received);
+
+ cs2Received.acknowledge();
+
+ Message cs2Received2 = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received second message", cs2Received2);
+ assertEquals("Differing groups", cs2Received2.getStringProperty(groupKey),
+ cs2Received.getStringProperty(groupKey));
+
+ cs1Received.acknowledge();
+ Message cs1Received2 = consumer1.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 1 should have received second message", cs1Received2);
+ assertEquals("Differing groups", cs1Received2.getStringProperty(groupKey),
+ cs1Received.getStringProperty(groupKey));
+
+ cs1Received2.acknowledge();
+ cs2Received2.acknowledge();
+
+ assertNull(consumer1.receive(getReceiveTimeout()));
+ assertNull(consumer2.receive(getReceiveTimeout()));
+ }
+ finally
+ {
+ consumerConnection.close();
+ }
+ }
+
+ @Test
+ public void consumerCloseGroupAssignment() throws Exception
+ {
+ consumerCloseGroupAssignment(false, false);
+ }
+
+ @Test
+ public void sharedGroupConsumerCloseGroupAssignment() throws Exception
+ {
+ consumerCloseGroupAssignment(true, false);
+ }
+
+ /**
+ *
+ * Tests that upon closing a consumer, groups previously assigned to that consumer are reassigned to a different
+ * consumer.
+ *
+ * Pre-populate the queue as ONE, ONE, TWO, ONE
+ *
+ * create in sequence two consumers
+ *
+ * receive first from c1 then c2 (thus ONE is assigned to c1, TWO to c2)
+ *
+ * Then close c1 before acking.
+ *
+ * If we now attempt to receive from c2, then the remaining messages in group ONE should be available (which
+ * requires c2 to go "backwards" in the queue).
+ *
+ **/
+ private void consumerCloseGroupAssignment(boolean sharedGroups, final boolean useDefaultGroup) throws Exception
+ {
+ final String groupKey = getGroupKey(useDefaultGroup);
+ String queueName = getTestName();
+ Destination queue = createQueue(queueName, sharedGroups, false);
+
+ final Connection producerConnection = getConnection();
+ try
+ {
+ final Session producerSession = producerConnection.createSession(true, SESSION_TRANSACTED);
+ final MessageProducer producer = producerSession.createProducer(queue);
+
+ producer.send(createMessage(producerSession, 1, "ONE", useDefaultGroup));
+ producer.send(createMessage(producerSession, 2, "ONE", useDefaultGroup));
+ producer.send(createMessage(producerSession, 3, "TWO", useDefaultGroup));
+ producer.send(createMessage(producerSession, 4, "ONE", useDefaultGroup));
+ producerSession.commit();
+ }
+ finally
+ {
+ producerConnection.close();
+ }
+
+ final Connection consumerConnection = getConnectionBuilder().setPrefetch(0).build();
+ try
+ {
+ consumerConnection.start();
+ Session cs1 = consumerConnection.createSession(true, SESSION_TRANSACTED);
+ Session cs2 = consumerConnection.createSession(true, SESSION_TRANSACTED);
+
+ MessageConsumer consumer1 = cs1.createConsumer(queue);
+ MessageConsumer consumer2 = cs2.createConsumer(queue);
+
+ Message cs1Received = consumer1.receive(getReceiveTimeout());
+ assertNotNull("Consumer 1 should have received first message", cs1Received);
+ assertEquals("incorrect message received", 1, cs1Received.getIntProperty("msg"));
+
+ Message cs2Received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received first message", cs2Received);
+ assertEquals("incorrect message received", 3, cs2Received.getIntProperty("msg"));
+ cs2.commit();
+
+ Message cs2Received2 = consumer2.receive(getReceiveTimeout());
+
+ assertNull("Consumer 2 should not yet have received a second message", cs2Received2);
+
+ consumer1.close();
+
+ cs1.commit();
+ Message cs2Received3 = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received second message", cs2Received3);
+ assertEquals("Unexpected group",
+ "ONE",
+ cs2Received3.getStringProperty(groupKey));
+ assertEquals("incorrect message received", 2, cs2Received3.getIntProperty("msg"));
+
+ cs2.commit();
+
+ Message cs2Received4 = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received third message", cs2Received4);
+ assertEquals("Unexpected group",
+ "ONE",
+ cs2Received4.getStringProperty(groupKey));
+ assertEquals("incorrect message received", 4, cs2Received4.getIntProperty("msg"));
+ cs2.commit();
+
+ assertNull(consumer2.receive(getReceiveTimeout()));
+ }
+ finally
+ {
+ consumerConnection.close();
+ }
+ }
+
+
+
+ @Test
+ public void consumerCloseWithRelease() throws Exception
+ {
+ consumerCloseWithRelease(false, false);
+ }
+
+ @Test
+ public void sharedGroupConsumerCloseWithRelease() throws Exception
+ {
+ consumerCloseWithRelease(true, false);
+ }
+
+ /**
+ *
+ * Tests that upon closing a consumer and its session, groups previously assigned to that consumer are reassigned
+ * to a different consumer, including messages which were previously delivered but have now been released.
+ *
+ * Pre-populate the queue as ONE, ONE, TWO, ONE
+ *
+ * create in sequence two consumers
+ *
+ * receive first from c1 then c2 (thus ONE is assigned to c1, TWO to c2)
+ *
+ * Then close c1 and its session without acking.
+ *
+ * If we now attempt to receive from c2, then the all messages in group ONE should be available (which
+ * requires c2 to go "backwards" in the queue). The first such message should be marked as redelivered
+ *
+ */
+ private void consumerCloseWithRelease(boolean sharedGroups, final boolean useDefaultGroup) throws Exception
+ {
+ String queueName = getTestName();
+ final String groupKey = getGroupKey(useDefaultGroup);
+ Destination queue = createQueue(queueName, sharedGroups, false);
+
+ final Connection producerConnection = getConnection();
+ try
+ {
+ producerConnection.start();
+ final Session producerSession = producerConnection.createSession(true, SESSION_TRANSACTED);
+ final MessageProducer producer = producerSession.createProducer(queue);
+
+ producer.send(createMessage(producerSession, 1, "ONE", useDefaultGroup));
+ producer.send(createMessage(producerSession, 2, "ONE", useDefaultGroup));
+ producer.send(createMessage(producerSession, 3, "TWO", useDefaultGroup));
+ producer.send(createMessage(producerSession, 4, "ONE", useDefaultGroup));
+ producerSession.commit();
+ }
+ finally
+ {
+ producerConnection.close();
+ }
+
+ final Connection consumerConnection = getConnectionBuilder().setPrefetch(0).build();
+ try
+ {
+ consumerConnection.start();
+
+ Session cs1 = consumerConnection.createSession(true, SESSION_TRANSACTED);
+ Session cs2 = consumerConnection.createSession(true, SESSION_TRANSACTED);
+
+ MessageConsumer consumer1 = cs1.createConsumer(queue);
+ MessageConsumer consumer2 = cs2.createConsumer(queue);
+
+ Message cs1Received = consumer1.receive(getReceiveTimeout());
+ assertNotNull("Consumer 1 should have received its first message", cs1Received);
+ assertEquals("incorrect message received", 1, cs1Received.getIntProperty("msg"));
+
+ Message received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received its first message", received);
+ assertEquals("incorrect message received", 3, received.getIntProperty("msg"));
+
+ Message received2 = consumer2.receive(getReceiveTimeout());
+
+ assertNull("Consumer 2 should not yet have received second message", received2);
+
+ consumer1.close();
+ cs1.close();
+ cs2.commit();
+
+ received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should now have received second message", received);
+ assertEquals("Unexpected group",
+ "ONE",
+ received.getStringProperty(groupKey));
+ assertEquals("incorrect message received", 1, received.getIntProperty("msg"));
+ assertTrue("Expected second message to be marked as redelivered " + received.getIntProperty("msg"),
+ received.getJMSRedelivered());
+
+ cs2.commit();
+
+ received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received a third message", received);
+ assertEquals("Unexpected group",
+ "ONE",
+ received.getStringProperty(groupKey));
+ assertEquals("incorrect message received", 2, received.getIntProperty("msg"));
+
+ cs2.commit();
+
+ received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received a fourth message", received);
+ assertEquals("Unexpected group",
+ "ONE",
+ received.getStringProperty(groupKey));
+ assertEquals("incorrect message received", 4, received.getIntProperty("msg"));
+
+ cs2.commit();
+
+ assertNull(consumer2.receive(getReceiveTimeout()));
+ }
+ finally
+ {
+ consumerConnection.close();
+ }
+ }
+
+ @Test
+ public void groupAssignmentSurvivesEmpty() throws Exception
+ {
+ groupAssignmentOnEmpty(false, false);
+ }
+
+ @Test
+ public void sharedGroupAssignmentDoesNotSurviveEmpty() throws Exception
+ {
+ groupAssignmentOnEmpty(true, false);
+ }
+
+ private void groupAssignmentOnEmpty(boolean sharedGroups, final boolean useDefaultGroup) throws Exception
+ {
+ String queueName = getTestName();
+ Destination queue = createQueue(queueName, sharedGroups, false);
+
+ final Connection producerConnection = getConnection();
+ try
+ {
+ producerConnection.start();
+ final Session producerSession = producerConnection.createSession(true, SESSION_TRANSACTED);
+ final MessageProducer producer = producerSession.createProducer(queue);
+
+ producer.send(createMessage(producerSession, 1, "ONE", useDefaultGroup));
+ producer.send(createMessage(producerSession, 2, "TWO", useDefaultGroup));
+ producer.send(createMessage(producerSession, 3, "THREE", useDefaultGroup));
+ producer.send(createMessage(producerSession, 4, "ONE", useDefaultGroup));
+ producerSession.commit();
+ }
+ finally
+ {
+ producerConnection.close();
+ }
+
+ final Connection consumerConnection = getConnectionBuilder().setPrefetch(0).build();
+ try
+ {
+ consumerConnection.start();
+
+ Session cs1 = consumerConnection.createSession(true, SESSION_TRANSACTED);
+ Session cs2 = consumerConnection.createSession(true, SESSION_TRANSACTED);
+
+ MessageConsumer consumer1 = cs1.createConsumer(queue);
+ MessageConsumer consumer2 = cs2.createConsumer(queue);
+
+ Message cs1Received = consumer1.receive(getReceiveTimeout());
+ assertNotNull("Consumer 1 should have received its first message", cs1Received);
+ assertEquals("incorrect message received", 1, cs1Received.getIntProperty("msg"));
+
+ Message cs2Received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received its first message", cs2Received);
+ assertEquals("incorrect message received", 2, cs2Received.getIntProperty("msg"));
+
+ cs1.commit();
+
+ cs1Received = consumer1.receive(getReceiveTimeout());
+ assertNotNull("Consumer 1 should have received its second message", cs1Received);
+ assertEquals("incorrect message received", 3, cs1Received.getIntProperty("msg"));
+
+ // We expect different behaviours from "shared groups": here the assignment of a subscription to a group
+ // is terminated when there are no outstanding delivered but unacknowledged messages. In contrast, with a
+ // standard message grouping queue the assignment will be retained until the subscription is no longer
+ // registered
+ if (sharedGroups)
+ {
+ cs2.commit();
+ cs2Received = consumer2.receive(getReceiveTimeout());
+
+ assertNotNull("Consumer 2 should have received its second message", cs2Received);
+ assertEquals("incorrect message received", 4, cs2Received.getIntProperty("msg"));
+
+ cs2.commit();
+ }
+ else
+ {
+ cs2.commit();
+ cs2Received = consumer2.receive(getReceiveTimeout());
+
+ assertNull("Consumer 2 should not have received a second message", cs2Received);
+
+ cs1.commit();
+
+ cs1Received = consumer1.receive(getReceiveTimeout());
+ assertNotNull("Consumer 1 should have received its third message", cs1Received);
+ assertEquals("incorrect message received", 4, cs1Received.getIntProperty("msg"));
+ }
+ }
+ finally
+ {
+ consumerConnection.close();
+ }
+
+ }
+
+ /**
+ * Tests that when a number of new messages for a given groupid are arriving while the delivery group
+ * state is also in the process of being emptied (due to acking a message while using prefetch=1), that only
+ * 1 of a number of existing consumers is ever receiving messages for the shared group at a time.
+ */
+ @Test
+ public void singleSharedGroupWithMultipleConsumers() throws Exception
+ {
+ String queueName = getTestName();
+ final boolean useDefaultGroup = false;
+ Destination queue = createQueue(queueName, true, useDefaultGroup);
+
+ final Connection consumerConnection = getConnectionBuilder().setPrefetch(1).build();
+ try
+ {
+ int numMessages = 100;
+ SharedGroupTestMessageListener groupingTestMessageListener =
+ new SharedGroupTestMessageListener(numMessages);
+
+ Session cs1 = consumerConnection.createSession(false, AUTO_ACKNOWLEDGE);
+ Session cs2 = consumerConnection.createSession(false, AUTO_ACKNOWLEDGE);
+ Session cs3 = consumerConnection.createSession(false, AUTO_ACKNOWLEDGE);
+ Session cs4 = consumerConnection.createSession(false, AUTO_ACKNOWLEDGE);
+
+ MessageConsumer consumer1 = cs1.createConsumer(queue);
+ consumer1.setMessageListener(groupingTestMessageListener);
+ MessageConsumer consumer2 = cs2.createConsumer(queue);
+ consumer2.setMessageListener(groupingTestMessageListener);
+ MessageConsumer consumer3 = cs3.createConsumer(queue);
+ consumer3.setMessageListener(groupingTestMessageListener);
+ MessageConsumer consumer4 = cs4.createConsumer(queue);
+ consumer4.setMessageListener(groupingTestMessageListener);
+ consumerConnection.start();
+
+ final Connection producerConnection = getConnection();
+ try
+ {
+ final Session producerSession = producerConnection.createSession(true, SESSION_TRANSACTED);
+ final MessageProducer producer = producerSession.createProducer(queue);
+
+ for (int i = 1; i <= numMessages; i++)
+ {
+ producer.send(createMessage(producerSession, i, "GROUP", useDefaultGroup));
+ }
+
+ producerSession.commit();
+ }
+ finally
+ {
+ producerConnection.close();
+ }
+
+ assertTrue("Mesages not all received in the allowed timeframe",
+ groupingTestMessageListener.waitForLatch(30));
+ assertEquals("Unexpected concurrent processing of messages for the group",
+ 0,
+ groupingTestMessageListener.getConcurrentProcessingCases());
+ assertNull("Unexpected throwable in message listeners", groupingTestMessageListener.getThrowable());
+ }
+ finally
+ {
+ consumerConnection.close();
+ }
+ }
+
+ private Destination createQueue(final String queueName, final boolean sharedGroups,
+ final boolean useDefaultKey) throws Exception
+ {
+ final Map<String, Object> arguments = new HashMap<>();
+ if(!useDefaultKey)
+ {
+ arguments.put(org.apache.qpid.server.model.Queue.MESSAGE_GROUP_KEY_OVERRIDE, "group");
+ }
+ arguments.put(ConfiguredObject.DURABLE, "false");
+ arguments.put(org.apache.qpid.server.model.Queue.MESSAGE_GROUP_TYPE, sharedGroups ? MessageGroupType.SHARED_GROUPS.name() : MessageGroupType.STANDARD.name());
+
+ createEntityUsingAmqpManagement(queueName, "org.apache.qpid.Queue", arguments);
+
+ return createQueue(queueName);
+ }
+
+ private Message createMessage(final Session session, int msg, String group, final boolean useDefaultGroup) throws JMSException
+ {
+ Message send = session.createTextMessage("Message: " + msg);
+ send.setIntProperty("msg", msg);
+ send.setStringProperty(getGroupKey(useDefaultGroup), group);
+
+ return send;
+ }
+
+ private String getGroupKey(final boolean useDefaultGroup)
+ {
+ return useDefaultGroup ? "JMSXGroupID" : "group";
+ }
+
+ public static class SharedGroupTestMessageListener implements MessageListener
+ {
+
+ private final CountDownLatch _count;
+ private final AtomicInteger _activeListeners = new AtomicInteger();
+ private final AtomicInteger _concurrentProcessingCases = new AtomicInteger();
+ private Throwable _throwable;
+
+ SharedGroupTestMessageListener(int numMessages)
+ {
+ _count = new CountDownLatch(numMessages);
+ }
+
+ @Override
+ public void onMessage(Message message)
+ {
+ try
+ {
+ int currentActiveListeners = _activeListeners.incrementAndGet();
+
+ if (currentActiveListeners > 1)
+ {
+ _concurrentProcessingCases.incrementAndGet();
+
+ LOGGER.error("Concurrent processing when handling message: " + message.getIntProperty("msg"));
+ }
+
+ try
+ {
+ Thread.sleep(25);
+ }
+ catch (InterruptedException e)
+ {
+ Thread.currentThread().interrupt();
+ }
+
+ _activeListeners.decrementAndGet();
+ }
+ catch (Throwable t)
+ {
+ LOGGER.error("Unexpected throwable received by listener", t);
+ _throwable = t;
+ }
+ finally
+ {
+ _count.countDown();
+ }
+ }
+
+ boolean waitForLatch(int seconds) throws Exception
+ {
+ return _count.await(seconds, TimeUnit.SECONDS);
+ }
+
+ int getConcurrentProcessingCases()
+ {
+ return _concurrentProcessingCases.get();
+ }
+
+ Throwable getThrowable()
+ {
+ return _throwable;
+ }
+ }
+}
http://git-wip-us.apache.org/repos/asf/qpid-broker-j/blob/b6186672/systests/src/test/java/org/apache/qpid/server/queue/MessageGroupQueueTest.java
----------------------------------------------------------------------
diff --git a/systests/src/test/java/org/apache/qpid/server/queue/MessageGroupQueueTest.java b/systests/src/test/java/org/apache/qpid/server/queue/MessageGroupQueueTest.java
deleted file mode 100644
index 31a7cc4..0000000
--- a/systests/src/test/java/org/apache/qpid/server/queue/MessageGroupQueueTest.java
+++ /dev/null
@@ -1,686 +0,0 @@
-/*
-*
-* 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.qpid.server.queue;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import javax.jms.Connection;
-import javax.jms.JMSException;
-import javax.jms.Message;
-import javax.jms.MessageConsumer;
-import javax.jms.MessageListener;
-import javax.jms.MessageProducer;
-import javax.jms.Queue;
-import javax.jms.Session;
-
-import org.apache.qpid.QpidException;
-import org.apache.qpid.server.model.ConfiguredObject;
-import org.apache.qpid.server.model.LifetimePolicy;
-import org.apache.qpid.test.utils.QpidBrokerTestCase;
-
-public class MessageGroupQueueTest extends QpidBrokerTestCase
-{
- protected final String QUEUE = "MessageGroupQueue";
-
- private Connection _producerConnection;
- private MessageProducer _producer;
- private Session _producerSession;
- private Queue _queue;
- private Connection _consumerConnection;
-
- @Override
- public void setUp() throws Exception
- {
- super.setUp();
-
- _producerConnection = getConnection();
- _producerSession = _producerConnection.createSession(true, Session.AUTO_ACKNOWLEDGE);
-
- _producerConnection.start();
-
- _consumerConnection = getConnectionWithPrefetch(0);
-
- }
-
- @Override
- public void tearDown() throws Exception
- {
- _producerConnection.close();
- _consumerConnection.close();
- super.tearDown();
- }
-
-
- public void testSimpleGroupAssignment() throws Exception
- {
- simpleGroupAssignment(false, false);
- }
-
- public void testSharedGroupSimpleGroupAssignment() throws Exception
- {
- simpleGroupAssignment(true, false);
- }
-
-
- public void testSimpleGroupAssignmentWithJMSXGroupID() throws Exception
- {
- simpleGroupAssignment(false, true);
- }
-
- public void testSharedGroupSimpleGroupAssignmentWithJMSXGroupID() throws Exception
- {
- simpleGroupAssignment(true, true);
- }
-
- /**
- * Pre populate the queue with messages with groups as follows
- *
- * ONE
- * TWO
- * ONE
- * TWO
- *
- * Create two consumers with prefetch of 1, the first consumer should then be assigned group ONE, the second
- * consumer assigned group TWO if they are started in sequence.
- *
- * Thus doing
- *
- * c1 <--- (ONE)
- * c2 <--- (TWO)
- * c2 ack --->
- *
- * c2 should now be able to receive a second message from group TWO (skipping over the message from group ONE)
- *
- * i.e.
- *
- * c2 <--- (TWO)
- * c2 ack --->
- * c1 <--- (ONE)
- * c1 ack --->
- *
- */
- private void simpleGroupAssignment(boolean sharedGroups, final boolean useDefaultGroup) throws QpidException, JMSException
- {
- createQueueAndProducer(sharedGroups, useDefaultGroup);
-
- String[] groups = { "ONE", "TWO"};
-
- for (int msg = 0; msg < 4; msg++)
- {
- _producer.send(createMessage(msg, groups[msg % groups.length], useDefaultGroup));
- }
- _producerSession.commit();
- _producer.close();
- _producerSession.close();
- _producerConnection.close();
-
- Session cs1 = _consumerConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
- Session cs2 = _consumerConnection.createSession(false, Session.CLIENT_ACKNOWLEDGE);
-
-
- MessageConsumer consumer1 = cs1.createConsumer(_queue);
- MessageConsumer consumer2 = cs2.createConsumer(_queue);
-
-
- _consumerConnection.start();
- Message cs1Received = consumer1.receive(getReceiveTimeout());
- assertNotNull("Consumer 1 should have received first message", cs1Received);
-
- Message cs2Received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received first message", cs2Received);
-
- cs2Received.acknowledge();
-
- Message cs2Received2 = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received second message", cs2Received2);
- assertEquals("Differing groups", cs2Received2.getStringProperty(useDefaultGroup ? "JMSXGroupID" :"group"),
- cs2Received.getStringProperty(useDefaultGroup ? "JMSXGroupID" :"group"));
-
- cs1Received.acknowledge();
- Message cs1Received2 = consumer1.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 1 should have received second message", cs1Received2);
- assertEquals("Differing groups", cs1Received2.getStringProperty(useDefaultGroup ? "JMSXGroupID" :"group"),
- cs1Received.getStringProperty(useDefaultGroup ? "JMSXGroupID" : "group"));
-
- cs1Received2.acknowledge();
- cs2Received2.acknowledge();
-
- assertNull(consumer1.receive(getShortReceiveTimeout()));
- assertNull(consumer2.receive(getShortReceiveTimeout()));
- }
-
- private void createQueueAndProducer(final boolean sharedGroups, final boolean useDefaultKey) throws QpidException, JMSException
- {
- if(isBroker10() || useDefaultKey)
- {
- final Map<String, Object> arguments = new HashMap<>();
- if(!useDefaultKey)
- {
- arguments.put(org.apache.qpid.server.model.Queue.MESSAGE_GROUP_KEY_OVERRIDE, "group");
- }
- arguments.put(ConfiguredObject.DURABLE, "false");
- arguments.put(ConfiguredObject.LIFETIME_POLICY, LifetimePolicy.DELETE_ON_NO_OUTBOUND_LINKS.toString());
- arguments.put(org.apache.qpid.server.model.Queue.MESSAGE_GROUP_TYPE, sharedGroups ? MessageGroupType.SHARED_GROUPS.name() : MessageGroupType.STANDARD.name());
-
- createEntityUsingAmqpManagement(QUEUE, _producerSession, "org.apache.qpid.Queue", arguments);
- _queue = _producerSession.createQueue(isBroker10() ? QUEUE : "ADDR:" + QUEUE + " ; {assert : never, node: { type: queue } }");
- }
- else
- {
- StringBuilder sb = new StringBuilder();
- sb.append("ADDR:");
- sb.append(QUEUE);
- sb.append(" ; {create : always, node: { type: queue, x-declare: { arguments: {'qpid.group_header_key' : group");
- if (sharedGroups)
- {
- sb.append(", 'qpid.shared_msg_group' : 1");
- }
- sb.append("} } } }");
- _queue = _producerSession.createQueue(sb.toString());
- }
- _producer = _producerSession.createProducer(_queue);
- }
-
-
- public void testConsumerCloseGroupAssignment() throws Exception
- {
- consumerCloseGroupAssignment(false, false);
- }
-
- public void testSharedGroupConsumerCloseGroupAssignment() throws Exception
- {
- consumerCloseGroupAssignment(true, false);
- }
-
- /**
- *
- * Tests that upon closing a consumer, groups previously assigned to that consumer are reassigned to a different
- * consumer.
- *
- * Pre-populate the queue as ONE, ONE, TWO, ONE
- *
- * create in sequence two consumers
- *
- * receive first from c1 then c2 (thus ONE is assigned to c1, TWO to c2)
- *
- * Then close c1 before acking.
- *
- * If we now attempt to receive from c2, then the remaining messages in group ONE should be available (which
- * requires c2 to go "backwards" in the queue).
- *
- **/
- private void consumerCloseGroupAssignment(boolean sharedGroups, final boolean useDefaultGroup) throws QpidException, JMSException
- {
- createQueueAndProducer(sharedGroups, false);
-
- _producer.send(createMessage(1, "ONE", useDefaultGroup));
- _producer.send(createMessage(2, "ONE", useDefaultGroup));
- _producer.send(createMessage(3, "TWO", useDefaultGroup));
- _producer.send(createMessage(4, "ONE", useDefaultGroup));
-
- _producerSession.commit();
- _producer.close();
- _producerSession.close();
- _producerConnection.close();
- boolean is010 = isBroker010();
- Session cs1 = _consumerConnection.createSession(!is010, is010 ? Session.CLIENT_ACKNOWLEDGE : Session.SESSION_TRANSACTED);
- Session cs2 = _consumerConnection.createSession(!is010, is010 ? Session.CLIENT_ACKNOWLEDGE : Session.SESSION_TRANSACTED);
-
- MessageConsumer consumer1 = cs1.createConsumer(_queue);
-
- _consumerConnection.start();
- MessageConsumer consumer2 = cs2.createConsumer(_queue);
-
- Message cs1Received = consumer1.receive(getReceiveTimeout());
- assertNotNull("Consumer 1 should have received first message", cs1Received);
- assertEquals("incorrect message received", 1, cs1Received.getIntProperty("msg"));
-
- Message cs2Received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received first message", cs2Received);
- assertEquals("incorrect message received", 3, cs2Received.getIntProperty("msg"));
- if(is010)
- {
- cs2Received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
-
- Message cs2Received2 = consumer2.receive(getShortReceiveTimeout());
-
- assertNull("Consumer 2 should not yet have received a second message", cs2Received2);
-
- consumer1.close();
-
- if(is010)
- {
- cs1Received.acknowledge();
- }
- else
- {
- cs1.commit();
- }
- Message cs2Received3 = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received second message", cs2Received3);
- assertEquals("Unexpected group", "ONE", cs2Received3.getStringProperty(useDefaultGroup ? "JMSXGroupID" : "group"));
- assertEquals("incorrect message received", 2, cs2Received3.getIntProperty("msg"));
-
- if(is010)
- {
- cs2Received3.acknowledge();
- }
- else
- {
- cs2.commit();
- }
-
-
- Message cs2Received4 = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received third message", cs2Received4);
- assertEquals("Unexpected group", "ONE", cs2Received4.getStringProperty(useDefaultGroup ? "JMSXGroupID" : "group"));
- assertEquals("incorrect message received", 4, cs2Received4.getIntProperty("msg"));
- if(is010)
- {
- cs2Received4.acknowledge();
- }
- else
- {
- cs2.commit();
- }
-
- assertNull(consumer2.receive(getShortReceiveTimeout()));
- }
-
-
-
-
- public void testConsumerCloseWithRelease() throws Exception
- {
- consumerCloseWithRelease(false, false);
- }
-
- public void testSharedGroupConsumerCloseWithRelease() throws Exception
- {
- consumerCloseWithRelease(true, false);
- }
-
-
- /**
- *
- * Tests that upon closing a consumer and its session, groups previously assigned to that consumer are reassigned
- * toa different consumer, including messages which were previously delivered but have now been released.
- *
- * Pre-populate the queue as ONE, ONE, TWO, ONE
- *
- * create in sequence two consumers
- *
- * receive first from c1 then c2 (thus ONE is assigned to c1, TWO to c2)
- *
- * Then close c1 and its session without acking.
- *
- * If we now attempt to receive from c2, then the all messages in group ONE should be available (which
- * requires c2 to go "backwards" in the queue). The first such message should be marked as redelivered
- *
- */
- private void consumerCloseWithRelease(boolean sharedGroups, final boolean useDefaultGroup) throws QpidException, JMSException
- {
- createQueueAndProducer(sharedGroups, false);
-
- _producer.send(createMessage(1, "ONE", useDefaultGroup));
- _producer.send(createMessage(2, "ONE", useDefaultGroup));
- _producer.send(createMessage(3, "TWO", useDefaultGroup));
- _producer.send(createMessage(4, "ONE", useDefaultGroup));
-
- _producerSession.commit();
- _producer.close();
- _producerSession.close();
- _producerConnection.close();
-
- boolean is010 = isBroker010();
- Session cs1 = _consumerConnection.createSession(!is010, is010 ? Session.CLIENT_ACKNOWLEDGE : Session.SESSION_TRANSACTED);
- Session cs2 = _consumerConnection.createSession(!is010, is010 ? Session.CLIENT_ACKNOWLEDGE : Session.SESSION_TRANSACTED);
-
-
- MessageConsumer consumer1 = cs1.createConsumer(_queue);
-
- _consumerConnection.start();
-
- MessageConsumer consumer2 = cs2.createConsumer(_queue);
-
- Message cs1Received = consumer1.receive(getReceiveTimeout());
- assertNotNull("Consumer 1 should have received its first message", cs1Received);
- assertEquals("incorrect message received", 1, cs1Received.getIntProperty("msg"));
-
- Message received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received its first message", received);
- assertEquals("incorrect message received", 3, received.getIntProperty("msg"));
-
- Message received2 = consumer2.receive(getShortReceiveTimeout());
-
- assertNull("Consumer 2 should not yet have received second message", received2);
-
- consumer1.close();
- cs1.close();
- if(is010)
- {
- received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
-
- received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should now have received second message", received);
- assertEquals("Unexpected group", "ONE", received.getStringProperty(useDefaultGroup ? "JMSXGroupID" : "group"));
- assertEquals("incorrect message received", 1, received.getIntProperty("msg"));
- assertTrue("Expected second message to be marked as redelivered " + received.getIntProperty("msg"),
- received.getJMSRedelivered());
-
- if(is010)
- {
- received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
-
- received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received a third message", received);
- assertEquals("Unexpected group", "ONE", received.getStringProperty(useDefaultGroup ? "JMSXGroupID" : "group"));
- assertEquals("incorrect message received", 2, received.getIntProperty("msg"));
-
- if(is010)
- {
- received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
-
- received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received a fourth message", received);
- assertEquals("Unexpected group", "ONE", received.getStringProperty(useDefaultGroup ? "JMSXGroupID" : "group"));
- assertEquals("incorrect message received", 4, received.getIntProperty("msg"));
-
- if(is010)
- {
- received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
-
- assertNull(consumer2.receive(getShortReceiveTimeout()));
- }
-
- public void testGroupAssignmentSurvivesEmpty() throws JMSException, QpidException
- {
- groupAssignmentOnEmpty(false, false);
- }
-
- public void testSharedGroupAssignmentDoesNotSurviveEmpty() throws JMSException, QpidException
- {
- groupAssignmentOnEmpty(true, false);
- }
-
- private void groupAssignmentOnEmpty(boolean sharedGroups, final boolean useDefaultGroup) throws QpidException, JMSException
- {
- createQueueAndProducer(sharedGroups, useDefaultGroup);
-
- _producer.send(createMessage(1, "ONE", useDefaultGroup));
- _producer.send(createMessage(2, "TWO", useDefaultGroup));
- _producer.send(createMessage(3, "THREE", useDefaultGroup));
- _producer.send(createMessage(4, "ONE", useDefaultGroup));
-
- _producerSession.commit();
- _producer.close();
- _producerSession.close();
- _producerConnection.close();
-
- boolean is010 = isBroker010();
- Session cs1 = _consumerConnection.createSession(!is010, is010 ? Session.CLIENT_ACKNOWLEDGE : Session.SESSION_TRANSACTED);
- Session cs2 = _consumerConnection.createSession(!is010, is010 ? Session.CLIENT_ACKNOWLEDGE : Session.SESSION_TRANSACTED);
-
-
- MessageConsumer consumer1 = cs1.createConsumer(_queue);
-
- _consumerConnection.start();
-
- MessageConsumer consumer2 = cs2.createConsumer(_queue);
-
- Message cs1Received = consumer1.receive(getReceiveTimeout());
- assertNotNull("Consumer 1 should have received its first message", cs1Received);
- assertEquals("incorrect message received", 1, cs1Received.getIntProperty("msg"));
-
- Message cs2Received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received its first message", cs2Received);
- assertEquals("incorrect message received", 2, cs2Received.getIntProperty("msg"));
-
- if(is010)
- {
- cs1Received.acknowledge();
- }
- else
- {
- cs1.commit();
- }
-
- cs1Received = consumer1.receive(getReceiveTimeout());
- assertNotNull("Consumer 1 should have received its second message", cs1Received);
- assertEquals("incorrect message received", 3, cs1Received.getIntProperty("msg"));
-
- // We expect different behaviours from "shared groups": here the assignment of a subscription to a group
- // is terminated when there are no outstanding delivered but unacknowledged messages. In contrast, with a
- // standard message grouping queue the assignment will be retained until the subscription is no longer
- // registered
- if(sharedGroups)
- {
- if(is010)
- {
- cs2Received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
- cs2Received = consumer2.receive(getReceiveTimeout());
-
- assertNotNull("Consumer 2 should have received its second message", cs2Received);
- assertEquals("incorrect message received", 4, cs2Received.getIntProperty("msg"));
-
- if(is010)
- {
- cs2Received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
- }
- else
- {
- if(is010)
- {
- cs2Received.acknowledge();
- }
- else
- {
- cs2.commit();
- }
- cs2Received = consumer2.receive(getShortReceiveTimeout());
-
- assertNull("Consumer 2 should not have received a second message", cs2Received);
-
- if(is010)
- {
- cs1Received.acknowledge();
- }
- else
- {
- cs1.commit();
- }
-
- cs1Received = consumer1.receive(getReceiveTimeout());
- assertNotNull("Consumer 1 should have received its third message", cs1Received);
- assertEquals("incorrect message received", 4, cs1Received.getIntProperty("msg"));
-
- }
-
- }
-
- private Message createMessage(int msg, String group, final boolean useDefaultGroup) throws JMSException
- {
- Message send = _producerSession.createTextMessage("Message: " + msg);
- send.setIntProperty("msg", msg);
- send.setStringProperty(useDefaultGroup ? "JMSXGroupID" : "group", group);
-
- return send;
- }
-
- /**
- * Tests that when a number of new messages for a given groupid are arriving while the delivery group
- * state is also in the process of being emptied (due to acking a message while using prefetch=1), that only
- * 1 of a number of existing consumers is ever receiving messages for the shared group at a time.
- */
- public void testSingleSharedGroupWithMultipleConsumers() throws Exception
- {
-
- _consumerConnection = getConnectionWithPrefetch(1);
-
- final boolean useDefaultGroup = false;
- createQueueAndProducer(true, useDefaultGroup);
-
- int numMessages = 100;
- SharedGroupTestMessageListener groupingTestMessageListener = new SharedGroupTestMessageListener(numMessages);
-
- Session cs1 = _consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
- Session cs2 = _consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
- Session cs3 = _consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
- Session cs4 = _consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
-
- MessageConsumer consumer1 = cs1.createConsumer(_queue);
- consumer1.setMessageListener(groupingTestMessageListener);
- MessageConsumer consumer2 = cs2.createConsumer(_queue);
- consumer2.setMessageListener(groupingTestMessageListener);
- MessageConsumer consumer3 = cs3.createConsumer(_queue);
- consumer3.setMessageListener(groupingTestMessageListener);
- MessageConsumer consumer4 = cs4.createConsumer(_queue);
- consumer4.setMessageListener(groupingTestMessageListener);
- _consumerConnection.start();
-
- for(int i = 1; i <= numMessages; i++)
- {
- _producer.send(createMessage(i, "GROUP", useDefaultGroup));
- }
- _producerSession.commit();
- _producer.close();
- _producerSession.close();
- _producerConnection.close();
-
- assertTrue("Mesages not all received in the allowed timeframe", groupingTestMessageListener.waitForLatch(30));
- assertEquals("Unexpected concurrent processing of messages for the group", 0, groupingTestMessageListener.getConcurrentProcessingCases());
- assertNull("Unexpected throwable in message listeners", groupingTestMessageListener.getThrowable());
- }
-
- public static class SharedGroupTestMessageListener implements MessageListener
- {
- private final CountDownLatch _count;
- private final AtomicInteger _activeListeners = new AtomicInteger();
- private final AtomicInteger _concurrentProcessingCases = new AtomicInteger();
- private Throwable _throwable;
-
- public SharedGroupTestMessageListener(int numMessages)
- {
- _count = new CountDownLatch(numMessages);
- }
-
- @Override
- public void onMessage(Message message)
- {
- try
- {
- int currentActiveListeners = _activeListeners.incrementAndGet();
-
- if (currentActiveListeners > 1)
- {
- _concurrentProcessingCases.incrementAndGet();
-
- System.err.println("Concurrent processing when handling message: " + message.getIntProperty("msg"));
- }
-
- try
- {
- Thread.sleep(25);
- }
- catch (InterruptedException e)
- {
- Thread.currentThread().interrupt();
- }
-
- _activeListeners.decrementAndGet();
- }
- catch (Throwable t)
- {
- _throwable = t;
- t.printStackTrace();
- }
- finally
- {
- _count.countDown();
- }
- }
-
- public boolean waitForLatch(int seconds) throws Exception
- {
- return _count.await(seconds, TimeUnit.SECONDS);
- }
-
- public int getConcurrentProcessingCases()
- {
- return _concurrentProcessingCases.get();
- }
-
- public Throwable getThrowable()
- {
- return _throwable;
- }
- }
-}
http://git-wip-us.apache.org/repos/asf/qpid-broker-j/blob/b6186672/test-profiles/CPPExcludes
----------------------------------------------------------------------
diff --git a/test-profiles/CPPExcludes b/test-profiles/CPPExcludes
index 1a0d4c5..c3e1657 100755
--- a/test-profiles/CPPExcludes
+++ b/test-profiles/CPPExcludes
@@ -127,12 +127,6 @@ org.apache.qpid.server.stats.StatisticsReportingTest#*
// QPID-3133: On 0-10, the exception listener is currently not invoked when reconnection fails to occurs.
org.apache.qpid.server.failover.FailoverMethodTest#*
-// CPP Broker does not implement non-"shared group" message groups
-org.apache.qpid.server.queue.MessageGroupQueueTest#testSimpleGroupAssignment
-org.apache.qpid.server.queue.MessageGroupQueueTest#testConsumerCloseGroupAssignment
-org.apache.qpid.server.queue.MessageGroupQueueTest#testConsumerCloseWithRelease
-org.apache.qpid.server.queue.MessageGroupQueueTest#testGroupAssignmentSurvivesEmpty
-
// passwd script is a Qpid Broker-J specific command line tool
org.apache.qpid.scripts.QpidPasswdTest#*
@@ -231,7 +225,3 @@ org.apache.qpid.systest.MessageRoutingTest#*
# Exchange to Exchange bindings not support by CPP Broker.
org.apache.qpid.server.routing.ExchangeRoutingTest#*
-
-# For 0-8..0-10 these tests assume that the Broker defaults to use header JMSXGroupID which is not true for the CPP Broker.
-org.apache.qpid.server.queue.MessageGroupQueueTest#testSharedGroupSimpleGroupAssignmentWithJMSXGroupID
-org.apache.qpid.server.queue.MessageGroupQueueTest#testSimpleGroupAssignmentWithJMSXGroupID
\ No newline at end of file
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@qpid.apache.org
For additional commands, e-mail: commits-help@qpid.apache.org