Repository: activemq-artemis
Updated Branches:
  refs/heads/master 5ea53c48e -> e790c7858


http://git-wip-us.apache.org/repos/asf/activemq-artemis/blob/113c0c93/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/amqp/AmqpTransactionTest.java
----------------------------------------------------------------------
diff --git 
a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/amqp/AmqpTransactionTest.java
 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/amqp/AmqpTransactionTest.java
new file mode 100644
index 0000000..e84534f
--- /dev/null
+++ 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/amqp/AmqpTransactionTest.java
@@ -0,0 +1,625 @@
+/**
+ * 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.tests.integration.amqp;
+
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+import org.apache.activemq.artemis.api.core.SimpleString;
+import org.apache.activemq.artemis.core.server.Queue;
+import org.apache.activemq.transport.amqp.client.AmqpClient;
+import org.apache.activemq.transport.amqp.client.AmqpConnection;
+import org.apache.activemq.transport.amqp.client.AmqpMessage;
+import org.apache.activemq.transport.amqp.client.AmqpReceiver;
+import org.apache.activemq.transport.amqp.client.AmqpSender;
+import org.apache.activemq.transport.amqp.client.AmqpSession;
+import org.junit.Before;
+import org.junit.Test;
+
+/**
+ * Test various aspects of Transaction support.
+ */
+public class AmqpTransactionTest extends AmqpClientTestSupport {
+
+   @Before
+   public void createQueue() throws Exception {
+      server.createQueue(SimpleString.toSimpleString(getTestName()), 
SimpleString.toSimpleString(getTestName()), null, true, false);
+   }
+
+   @Test(timeout = 30000)
+   public void testBeginAndCommitTransaction() throws Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+      AmqpSession session = connection.createSession();
+      assertNotNull(session);
+
+      session.begin();
+      assertTrue(session.isInTransaction());
+      session.commit();
+
+      connection.close();
+   }
+
+   @Test(timeout = 30000)
+   public void testBeginAndRollbackTransaction() throws Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+      AmqpSession session = connection.createSession();
+      assertNotNull(session);
+
+      session.begin();
+      assertTrue(session.isInTransaction());
+      session.rollback();
+
+      connection.close();
+
+      System.err.println("Closed");
+   }
+
+   @Test(timeout = 60000)
+   public void testSendMessageToQueueWithCommit() throws Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+      AmqpSession session = connection.createSession();
+
+      AmqpSender sender = session.createSender(getTestName());
+      final Queue queue = getProxyToQueue(getTestName());
+
+      session.begin();
+
+      AmqpMessage message = new AmqpMessage();
+      message.setText("Test-Message");
+      sender.send(message);
+
+      assertEquals(0, queue.getMessageCount());
+
+      session.commit();
+
+      assertEquals(1, queue.getMessageCount());
+
+      sender.close();
+      connection.close();
+   }
+
+   @Test(timeout = 60000)
+   public void testSendMessageToQueueWithRollback() throws Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+      AmqpSession session = connection.createSession();
+
+      AmqpSender sender = session.createSender(getTestName());
+      final Queue queue = getProxyToQueue(getTestName());
+
+      session.begin();
+
+      AmqpMessage message = new AmqpMessage();
+      message.setText("Test-Message");
+      sender.send(message);
+
+      assertEquals(0, queue.getMessageCount());
+
+      session.rollback();
+
+      assertEquals(0, queue.getMessageCount());
+
+      sender.close();
+      connection.close();
+   }
+
+   @Test(timeout = 60000)
+   public void testReceiveMessageWithCommit() throws Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+      AmqpSession session = connection.createSession();
+
+      AmqpSender sender = session.createSender(getTestName());
+      final Queue queue = getProxyToQueue(getTestName());
+
+      AmqpMessage message = new AmqpMessage();
+      message.setText("Test-Message");
+      sender.send(message);
+
+      assertEquals(1, queue.getMessageCount());
+
+      AmqpReceiver receiver = session.createReceiver(getTestName());
+
+      session.begin();
+
+      receiver.flow(1);
+      AmqpMessage received = receiver.receive(5, TimeUnit.SECONDS);
+      assertNotNull(received);
+      received.accept();
+
+      session.commit();
+
+      assertEquals(0, queue.getMessageCount());
+
+      sender.close();
+      connection.close();
+   }
+
+   @Test(timeout = 60000)
+   public void testReceiveAfterConnectionClose() throws Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+      AmqpSession session = connection.createSession();
+
+      AmqpSender sender = session.createSender(getTestName());
+      final Queue queue = getProxyToQueue(getTestName());
+
+      AmqpMessage message = new AmqpMessage();
+      message.setText("Test-Message");
+      sender.send(message);
+
+      assertEquals(1, queue.getMessageCount());
+
+      AmqpReceiver receiver = session.createReceiver(getTestName());
+
+      session.begin();
+
+      receiver.flow(1);
+      AmqpMessage received = receiver.receive(5, TimeUnit.SECONDS);
+      assertNotNull(received);
+      received.accept();
+
+      // this will force a rollback on the TX (It should at least)
+      connection.close();
+
+      connection = addConnection(client.connect());
+      session = connection.createSession();
+      receiver = session.createReceiver(getTestName());
+      session.begin();
+      receiver.flow(1);
+
+      received = receiver.receive(5, TimeUnit.SECONDS);
+      assertNotNull(received);
+      received.accept();
+
+      session.commit();
+
+      assertEquals(0, queue.getMessageCount());
+
+      connection.close();
+   }
+
+   @Test(timeout = 60000)
+   public void testReceiveMessageWithRollback() throws Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+      AmqpSession session = connection.createSession();
+
+      AmqpSender sender = session.createSender(getTestName());
+      final Queue queue = getProxyToQueue(getTestName());
+
+      AmqpMessage message = new AmqpMessage();
+      message.setText("Test-Message");
+      sender.send(message);
+
+      assertEquals(1, queue.getMessageCount());
+
+      AmqpReceiver receiver = session.createReceiver(getTestName());
+
+      session.begin();
+
+      receiver.flow(1);
+      AmqpMessage received = receiver.receive(5, TimeUnit.SECONDS);
+      assertNotNull(received);
+      received.accept();
+
+      session.rollback();
+
+      assertEquals(1, queue.getMessageCount());
+
+      sender.close();
+      connection.close();
+   }
+
+   @Test(timeout = 60000)
+   public void testMultipleSessionReceiversInSingleTXNWithCommit() throws 
Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+
+      // Load up the Queue with some messages
+      {
+         AmqpSession session = connection.createSession();
+         AmqpSender sender = session.createSender(getTestName());
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         sender.send(message);
+         sender.send(message);
+         sender.send(message);
+         sender.close();
+      }
+
+      // Root TXN session controls all TXN send lifetimes.
+      AmqpSession txnSession = connection.createSession();
+
+      // Create some sender sessions
+      AmqpSession session1 = connection.createSession();
+      AmqpSession session2 = connection.createSession();
+      AmqpSession session3 = connection.createSession();
+
+      // Sender linked to each session
+      AmqpReceiver receiver1 = session1.createReceiver(getTestName());
+      AmqpReceiver receiver2 = session2.createReceiver(getTestName());
+      AmqpReceiver receiver3 = session3.createReceiver(getTestName());
+
+      final Queue queue = getProxyToQueue(getTestName());
+      assertEquals(3, queue.getMessageCount());
+
+      // Begin the transaction that all senders will operate in.
+      txnSession.begin();
+
+      assertTrue(txnSession.isInTransaction());
+
+      receiver1.flow(1);
+      receiver2.flow(1);
+      receiver3.flow(1);
+
+      AmqpMessage message1 = receiver1.receive(5, TimeUnit.SECONDS);
+      AmqpMessage message2 = receiver2.receive(5, TimeUnit.SECONDS);
+      AmqpMessage message3 = receiver3.receive(5, TimeUnit.SECONDS);
+
+      message1.accept(txnSession);
+      message2.accept(txnSession);
+      message3.accept(txnSession);
+
+      assertEquals(3, queue.getMessageCount());
+
+      txnSession.commit();
+
+      assertEquals(0, queue.getMessageCount());
+   }
+
+   @Test(timeout = 60000)
+   public void testMultipleSessionReceiversInSingleTXNWithRollback() throws 
Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+
+      // Load up the Queue with some messages
+      {
+         AmqpSession session = connection.createSession();
+         AmqpSender sender = session.createSender(getTestName());
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         sender.send(message);
+         sender.send(message);
+         sender.send(message);
+         sender.close();
+      }
+
+      // Root TXN session controls all TXN send lifetimes.
+      AmqpSession txnSession = connection.createSession();
+
+      // Create some sender sessions
+      AmqpSession session1 = connection.createSession();
+      AmqpSession session2 = connection.createSession();
+      AmqpSession session3 = connection.createSession();
+
+      // Sender linked to each session
+      AmqpReceiver receiver1 = session1.createReceiver(getTestName());
+      AmqpReceiver receiver2 = session2.createReceiver(getTestName());
+      AmqpReceiver receiver3 = session3.createReceiver(getTestName());
+
+      final Queue queue = getProxyToQueue(getTestName());
+      assertEquals(3, queue.getMessageCount());
+
+      // Begin the transaction that all senders will operate in.
+      txnSession.begin();
+
+      assertTrue(txnSession.isInTransaction());
+
+      receiver1.flow(1);
+      receiver2.flow(1);
+      receiver3.flow(1);
+
+      AmqpMessage message1 = receiver1.receive(5, TimeUnit.SECONDS);
+      AmqpMessage message2 = receiver2.receive(5, TimeUnit.SECONDS);
+      AmqpMessage message3 = receiver3.receive(5, TimeUnit.SECONDS);
+
+      message1.accept(txnSession);
+      message2.accept(txnSession);
+      message3.accept(txnSession);
+
+      assertEquals(3, queue.getMessageCount());
+
+      txnSession.rollback();
+
+      assertEquals(3, queue.getMessageCount());
+   }
+
+   @Test(timeout = 60000)
+   public void testMultipleSessionSendersInSingleTXNWithCommit() throws 
Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+
+      // Root TXN session controls all TXN send lifetimes.
+      AmqpSession txnSession = connection.createSession();
+
+      // Create some sender sessions
+      AmqpSession session1 = connection.createSession();
+      AmqpSession session2 = connection.createSession();
+      AmqpSession session3 = connection.createSession();
+
+      // Sender linked to each session
+      AmqpSender sender1 = session1.createSender(getTestName());
+      AmqpSender sender2 = session2.createSender(getTestName());
+      AmqpSender sender3 = session3.createSender(getTestName());
+
+      final Queue queue = getProxyToQueue(getTestName());
+      assertEquals(0, queue.getMessageCount());
+
+      // Begin the transaction that all senders will operate in.
+      txnSession.begin();
+
+      AmqpMessage message = new AmqpMessage();
+      message.setText("Test-Message");
+
+      assertTrue(txnSession.isInTransaction());
+
+      sender1.send(message, txnSession.getTransactionId());
+      sender2.send(message, txnSession.getTransactionId());
+      sender3.send(message, txnSession.getTransactionId());
+
+      assertEquals(0, queue.getMessageCount());
+
+      txnSession.commit();
+
+      assertEquals(3, queue.getMessageCount());
+   }
+
+   @Test(timeout = 60000)
+   public void testMultipleSessionSendersInSingleTXNWithRollback() throws 
Exception {
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+
+      // Root TXN session controls all TXN send lifetimes.
+      AmqpSession txnSession = connection.createSession();
+
+      // Create some sender sessions
+      AmqpSession session1 = connection.createSession();
+      AmqpSession session2 = connection.createSession();
+      AmqpSession session3 = connection.createSession();
+
+      // Sender linked to each session
+      AmqpSender sender1 = session1.createSender(getTestName());
+      AmqpSender sender2 = session2.createSender(getTestName());
+      AmqpSender sender3 = session3.createSender(getTestName());
+
+      final Queue queue = getProxyToQueue(getTestName());
+      assertEquals(0, queue.getMessageCount());
+
+      // Begin the transaction that all senders will operate in.
+      txnSession.begin();
+
+      AmqpMessage message = new AmqpMessage();
+      message.setText("Test-Message");
+
+      assertTrue(txnSession.isInTransaction());
+
+      sender1.send(message, txnSession.getTransactionId());
+      sender2.send(message, txnSession.getTransactionId());
+      sender3.send(message, txnSession.getTransactionId());
+
+      assertEquals(0, queue.getMessageCount());
+
+      txnSession.rollback();
+
+      assertEquals(0, queue.getMessageCount());
+   }
+
+   //----- Tests Ported from AmqpNetLite client -----------------------------//
+
+   @Test(timeout = 60000)
+   public void testSendersCommitAndRollbackWithMultipleSessionsInSingleTX() 
throws Exception {
+      final int NUM_MESSAGES = 5;
+
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+
+      // Root TXN session controls all TXN send lifetimes.
+      AmqpSession txnSession = connection.createSession();
+
+      // Normal Session which won't create an TXN itself
+      AmqpSession session = connection.createSession();
+
+      AmqpSender sender = session.createSender(getTestName());
+
+      // Commit TXN work from a sender.
+      txnSession.begin();
+      for (int i = 0; i < NUM_MESSAGES; ++i) {
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         sender.send(message, txnSession.getTransactionId());
+      }
+      txnSession.commit();
+
+      // Rollback an additional batch of TXN work from a sender.
+      txnSession.begin();
+      for (int i = 0; i < NUM_MESSAGES; ++i) {
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         sender.send(message, txnSession.getTransactionId());
+      }
+      txnSession.rollback();
+
+      // Commit more TXN work from a sender.
+      txnSession.begin();
+      for (int i = 0; i < NUM_MESSAGES; ++i) {
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         sender.send(message, txnSession.getTransactionId());
+      }
+      txnSession.commit();
+
+      AmqpReceiver receiver = session.createReceiver(getTestName());
+      receiver.flow(NUM_MESSAGES * 2);
+      for (int i = 0; i < NUM_MESSAGES * 2; ++i) {
+         AmqpMessage message = receiver.receive(5, TimeUnit.SECONDS);
+         assertNotNull(message);
+         message.accept(txnSession);
+      }
+
+      connection.close();
+   }
+
+   @Test(timeout = 60000)
+   public void testReceiversCommitAndRollbackWithMultipleSessionsInSingleTX() 
throws Exception {
+      final int NUM_MESSAGES = 10;
+
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+
+      // Root TXN session controls all TXN send lifetimes.
+      AmqpSession txnSession = connection.createSession();
+
+      // Normal Session which won't create an TXN itself
+      AmqpSession session = connection.createSession();
+      AmqpSender sender = session.createSender(getTestName());
+
+      for (int i = 0; i < NUM_MESSAGES + 1; ++i) {
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         message.setApplicationProperty("msgId", i);
+         sender.send(message, txnSession.getTransactionId());
+      }
+
+      // Read all messages from the Queue, do not accept them yet.
+      AmqpReceiver receiver = session.createReceiver(getTestName());
+      ArrayList<AmqpMessage> messages = new ArrayList<>(NUM_MESSAGES);
+      receiver.flow((NUM_MESSAGES + 2) * 2);
+      for (int i = 0; i < NUM_MESSAGES; ++i) {
+         AmqpMessage message = receiver.receive(5, TimeUnit.SECONDS);
+         assertNotNull(message);
+         messages.add(message);
+      }
+
+      // Commit half the consumed messages
+      txnSession.begin();
+      for (int i = 0; i < NUM_MESSAGES / 2; ++i) {
+         messages.get(i).accept(txnSession);
+      }
+      txnSession.commit();
+
+      // Rollback the other half the consumed messages
+      txnSession.begin();
+      for (int i = NUM_MESSAGES / 2; i < NUM_MESSAGES; ++i) {
+         messages.get(i).accept(txnSession);
+      }
+      txnSession.rollback();
+
+      {
+         AmqpMessage message = receiver.receive(5, TimeUnit.SECONDS);
+         assertNotNull(message);
+         assertEquals(NUM_MESSAGES, message.getApplicationProperty("msgId"));
+         message.release();
+      }
+
+      // Commit the other half the consumed messages
+      // This is a variation from the .NET client tests which doesn't settle 
the
+      // messages in the TX until commit is called but on ActiveMQ they will be
+      // redispatched regardless and not stay in the acquired state.
+      txnSession.begin();
+      for (int i = NUM_MESSAGES / 2; i < NUM_MESSAGES; ++i) {
+         AmqpMessage message = receiver.receive(5, TimeUnit.SECONDS);
+         assertNotNull(message);
+         message.accept();
+      }
+      txnSession.commit();
+
+      // The final message should still be pending.
+      {
+         AmqpMessage message = receiver.receive(5, TimeUnit.SECONDS);
+         receiver.flow(1);
+         assertNotNull(message);
+         assertEquals(NUM_MESSAGES, message.getApplicationProperty("msgId"));
+         message.release();
+      }
+
+      connection.close();
+   }
+
+   @Test(timeout = 60000)
+   public void testCommitAndRollbackWithMultipleSessionsInSingleTX() throws 
Exception {
+      final int NUM_MESSAGES = 10;
+
+      AmqpClient client = createAmqpClient();
+      AmqpConnection connection = addConnection(client.connect());
+
+      // Root TXN session controls all TXN send lifetimes.
+      AmqpSession txnSession = connection.createSession();
+
+      // Normal Session which won't create an TXN itself
+      AmqpSession session = connection.createSession();
+      AmqpSender sender = session.createSender(getTestName());
+
+      for (int i = 0; i < NUM_MESSAGES; ++i) {
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         message.setApplicationProperty("msgId", i);
+         sender.send(message, txnSession.getTransactionId());
+      }
+
+      // Read all messages from the Queue, do not accept them yet.
+      AmqpReceiver receiver = session.createReceiver(getTestName());
+      receiver.flow(2);
+      AmqpMessage message1 = receiver.receive(5, TimeUnit.SECONDS);
+      AmqpMessage message2 = receiver.receive(5, TimeUnit.SECONDS);
+
+      // Accept the first one in a TXN and send a new message in that TXN as 
well
+      txnSession.begin();
+      {
+         message1.accept(txnSession);
+
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         message.setApplicationProperty("msgId", NUM_MESSAGES);
+
+         sender.send(message, txnSession.getTransactionId());
+      }
+      txnSession.commit();
+
+      // Accept the second one in a TXN and send a new message in that TXN as 
well but rollback
+      txnSession.begin();
+      {
+         message2.accept(txnSession);
+
+         AmqpMessage message = new AmqpMessage();
+         message.setText("Test-Message");
+         message.setApplicationProperty("msgId", NUM_MESSAGES + 1);
+         sender.send(message, txnSession.getTransactionId());
+      }
+      txnSession.rollback();
+
+      // Variation here from .NET code, the client settles the accepted 
message where
+      // the .NET client does not and instead releases here to have it 
redelivered.
+
+      receiver.flow(NUM_MESSAGES);
+      for (int i = 1; i <= NUM_MESSAGES; ++i) {
+         AmqpMessage message = receiver.receive(5, TimeUnit.SECONDS);
+         assertNotNull(message);
+         assertEquals(i, message.getApplicationProperty("msgId"));
+         message.accept();
+      }
+
+      // Should be nothing left.
+      assertNull(receiver.receive(1, TimeUnit.SECONDS));
+
+      connection.close();
+   }
+}

http://git-wip-us.apache.org/repos/asf/activemq-artemis/blob/113c0c93/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTest.java
----------------------------------------------------------------------
diff --git 
a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTest.java
 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTest.java
index 193b46b..984459e 100644
--- 
a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTest.java
+++ 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTest.java
@@ -815,7 +815,8 @@ public class ProtonTest extends ProtonTestBase {
          request.setText("[]");
 
          sender.send(request);
-         AmqpMessage response = receiver.receive();
+         AmqpMessage response = receiver.receive(50, TimeUnit.SECONDS);
+         Assert.assertNotNull(response);
          assertNotNull(response);
          Object section = response.getWrappedMessage().getBody();
          assertTrue(section instanceof AmqpValue);

http://git-wip-us.apache.org/repos/asf/activemq-artemis/blob/113c0c93/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestBase.java
----------------------------------------------------------------------
diff --git 
a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestBase.java
 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestBase.java
index 0acd4ae..cec59da 100644
--- 
a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestBase.java
+++ 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestBase.java
@@ -41,7 +41,6 @@ public class ProtonTestBase extends ActiveMQTestBase {
    @Before
    public void setUp() throws Exception {
       super.setUp();
-      disableCheckThread();
 
       server = this.createServer(true, true);
       HashMap<String, Object> params = new HashMap<>();

http://git-wip-us.apache.org/repos/asf/activemq-artemis/blob/113c0c93/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestForHeader.java
----------------------------------------------------------------------
diff --git 
a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestForHeader.java
 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestForHeader.java
index b4a6a34..d23bd5b 100644
--- 
a/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestForHeader.java
+++ 
b/tests/integration-tests/src/test/java/org/apache/activemq/artemis/tests/integration/proton/ProtonTestForHeader.java
@@ -43,7 +43,6 @@ public class ProtonTestForHeader extends ActiveMQTestBase {
    @Before
    public void setUp() throws Exception {
       super.setUp();
-      disableCheckThread();
       server = this.createServer(true, true);
       HashMap<String, Object> params = new HashMap<>();
       params.put(TransportConstants.PORT_PROP_NAME, "5672");
@@ -61,8 +60,6 @@ public class ProtonTestForHeader extends ActiveMQTestBase {
    @After
    public void tearDown() throws Exception {
       try {
-         Thread.sleep(250);
-
          server.stop();
       }
       finally {

Reply via email to