/*
 * 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.client;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

import org.apache.activemq.artemis.api.core.ActiveMQException;
import org.apache.activemq.artemis.api.core.ActiveMQInternalErrorException;
import org.apache.activemq.artemis.api.core.QueueConfiguration;
import org.apache.activemq.artemis.api.core.RoutingType;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.api.core.client.ClientConsumer;
import org.apache.activemq.artemis.api.core.client.ClientMessage;
import org.apache.activemq.artemis.api.core.client.ClientProducer;
import org.apache.activemq.artemis.api.core.client.ClientSession;
import org.apache.activemq.artemis.api.core.client.ClientSession.QueueQuery;
import org.apache.activemq.artemis.api.core.client.ClientSessionFactory;
import org.apache.activemq.artemis.api.core.client.ServerLocator;
import org.apache.activemq.artemis.api.core.client.SessionFailureListener;
import org.apache.activemq.artemis.core.client.impl.ClientSessionFactoryInternal;
import org.apache.activemq.artemis.core.client.impl.ClientSessionInternal;
import org.apache.activemq.artemis.core.server.ActiveMQServer;
import org.apache.activemq.artemis.core.server.Queue;
import org.apache.activemq.artemis.core.settings.impl.AddressSettings;
import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
import org.apache.activemq.artemis.tests.extensions.parameterized.ParameterizedTestExtension;
import org.apache.activemq.artemis.tests.extensions.parameterized.Parameters;
import org.apache.activemq.artemis.tests.util.ActiveMQTestBase;
import org.apache.activemq.artemis.tests.util.CountDownSessionFailureListener;
import org.apache.activemq.artemis.tests.util.Wait;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.TestTemplate;
import org.junit.jupiter.api.extension.ExtendWith;

/**
 * This test covers the API for ClientSession although XA tests are tested separately.
 */
@ExtendWith(ParameterizedTestExtension.class)
public class SessionTest extends ActiveMQTestBase {

   private boolean legacyCreateQueue;

   private final String queueName = "ClientSessionTestQ";

   private ServerLocator locator;
   private ActiveMQServer server;
   private ClientSessionFactory cf;

   @Parameters(name = "legacyCreateQueue={0}")
   public static Collection<Object[]> getParams() {
      return Arrays.asList(new Object[][]{{true}, {false}});
   }

   public SessionTest(boolean legacyCreateQueue) {
      this.legacyCreateQueue = legacyCreateQueue;
   }

   @Override
   @BeforeEach
   public void setUp() throws Exception {
      super.setUp();

      locator = createInVMNonHALocator();
      server = createServer(false);
      server.start();
      waitForServerToStart(server);
   }

   @TestTemplate
   public void testFailureListener() throws Exception {

      cf = createSessionFactory(locator);
      ClientSession clientSession = addClientSession(cf.createSession(false, true, true));
      CountDownSessionFailureListener listener = new CountDownSessionFailureListener(clientSession);
      clientSession.addFailureListener(listener);
      // Make sure failure listener is called if server is stopped without session being closed first
      server.stop();
      assertTrue(listener.getLatch().await(5, TimeUnit.SECONDS));
   }

   @TestTemplate
   public void testFailureListenerRemoved() throws Exception {
      cf = createSessionFactory(locator);
      try {
         ClientSession clientSession = cf.createSession(false, true, true);
         class MyFailureListener implements SessionFailureListener {

            boolean called = false;

            @Override
            public void connectionFailed(final ActiveMQException me, boolean failedOver) {
               called = true;
            }

            @Override
            public void connectionFailed(final ActiveMQException me, boolean failedOver, String scaleDownTargetNodeID) {
               connectionFailed(me, failedOver);
            }

            @Override
            public void beforeReconnect(final ActiveMQException me) {
            }
         }

         MyFailureListener listener = new MyFailureListener();
         clientSession.addFailureListener(listener);

         assertTrue(clientSession.removeFailureListener(listener));
         clientSession.close();
         server.stop();
         assertFalse(listener.called);
      } finally {
         ((ClientSessionFactoryInternal) cf).causeExit();
         cf.close();
      }
   }

   // Closing a session if the underlying remoting connection is dead should cleanly
   // release all resources
   @TestTemplate
   public void testCloseSessionOnDestroyedConnection() throws Exception {
      // Make sure we have a short connection TTL so sessions will be quickly closed on the server
      server.stop();
      long ttl = 500;
      server.getConfiguration().setConnectionTTLOverride(ttl);
      server.start();
      cf = createSessionFactory(locator);
      ClientSessionInternal clientSession = (ClientSessionInternal) cf.createSession(false, true, true);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      /** keep unused variables in order to maintain references to both objects */
      @SuppressWarnings("unused")
      ClientProducer producer = clientSession.createProducer();
      @SuppressWarnings("unused")
      ClientConsumer consumer = clientSession.createConsumer(queueName);

      assertEquals(1, server.getRemotingService().getConnections().size());

      RemotingConnection rc = clientSession.getConnection();

      rc.fail(new ActiveMQInternalErrorException());

      clientSession.close();

      long start = System.currentTimeMillis();

      while (true) {
         int cons = server.getRemotingService().getConnections().size();

         if (cons == 0) {
            break;
         }

         long now = System.currentTimeMillis();

         if (now - start > 10000) {
            throw new Exception("Timed out waiting for connections to close");
         }

         Thread.sleep(50);
      }
   }

   @TestTemplate
   public void testBindingQuery() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      if (legacyCreateQueue) {
         clientSession.createQueue("a1", "q1", false);
         clientSession.createQueue("a1", "q2", false);
         clientSession.createQueue("a2", "q3", false);
         clientSession.createQueue("a2", "q4", false);
         clientSession.createQueue("a2", "q5", false);
      } else {
         clientSession.createQueue(QueueConfiguration.of("q1").setAddress("a1").setDurable(false));
         clientSession.createQueue(QueueConfiguration.of("q2").setAddress("a1").setDurable(false));
         clientSession.createQueue(QueueConfiguration.of("q3").setAddress("a2").setDurable(false));
         clientSession.createQueue(QueueConfiguration.of("q4").setAddress("a2").setDurable(false));
         clientSession.createQueue(QueueConfiguration.of("q5").setAddress("a2").setDurable(false));
      }
      ClientSession.AddressQuery resp = clientSession.addressQuery(SimpleString.of("a"));
      List<SimpleString> queues = resp.getQueueNames();
      assertTrue(queues.isEmpty());
      resp = clientSession.addressQuery(SimpleString.of("a1"));
      queues = resp.getQueueNames();
      assertEquals(queues.size(), 2);
      assertTrue(queues.contains(SimpleString.of("q1")));
      assertTrue(queues.contains(SimpleString.of("q2")));
      resp = clientSession.addressQuery(SimpleString.of("a2"));
      queues = resp.getQueueNames();
      assertEquals(queues.size(), 3);
      assertTrue(queues.contains(SimpleString.of("q3")));
      assertTrue(queues.contains(SimpleString.of("q4")));
      assertTrue(queues.contains(SimpleString.of("q5")));
      clientSession.close();
   }

   @TestTemplate
   public void testQueueQuery() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      if (legacyCreateQueue) {
         clientSession.createQueue("a1", queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setAddress("a1").setDurable(false));
      }
      // I'm holding a reference here on purpose to avoid GC and unexpected closes.. etc
      ClientConsumer consumer1 = clientSession.createConsumer(queueName);
      ClientConsumer consumer2 = clientSession.createConsumer(queueName);
      ClientProducer cp = clientSession.createProducer("a1");
      cp.send(clientSession.createMessage(true));
      cp.send(clientSession.createMessage(true));

      Queue queue = flushQueue();
      Wait.assertEquals(2, queue::getMessageCount);
      Wait.assertEquals(2, queue::getConsumerCount);

      QueueQuery resp = clientSession.queueQuery(SimpleString.of(queueName));
      assertEquals(SimpleString.of("a1"), resp.getAddress());
      assertEquals(2, resp.getConsumerCount());
      assertEquals(2, resp.getMessageCount());
      assertNull(resp.getFilterString());
      consumer1.close();
      consumer2.close();
      clientSession.close();
   }

   private Queue flushQueue() throws Exception {
      Queue queue = server.locateQueue(SimpleString.of(queueName));
      assertNotNull(queue);
      queue.flushExecutor();
      return queue;
   }

   @TestTemplate
   public void testQueueQueryWithFilter() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      if (legacyCreateQueue) {
         clientSession.createQueue("a1", queueName, "foo=bar", false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setAddress("a1").setFilterString("foo=bar").setDurable(false));
      }
      clientSession.createConsumer(queueName);
      clientSession.createConsumer(queueName);

      QueueQuery resp = clientSession.queueQuery(SimpleString.of(queueName));
      assertEquals(SimpleString.of("a1"), resp.getAddress());
      assertEquals(2, resp.getConsumerCount());
      assertEquals(0, resp.getMessageCount());
      assertEquals(SimpleString.of("foo=bar"), resp.getFilterString());
      clientSession.close();
   }

   @TestTemplate
   public void testQueueQueryNoQ() throws Exception {
      server.getAddressSettingsRepository().addMatch("#", new AddressSettings().setAutoCreateQueues(false));
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      QueueQuery resp = clientSession.queueQuery(SimpleString.of(queueName));
      assertFalse(resp.isExists());
      assertFalse(resp.isAutoCreateQueues());
      assertEquals(queueName, resp.getAddress().toString());
      clientSession.close();
   }

   @TestTemplate
   public void testClose() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      ClientProducer p = clientSession.createProducer();
      ClientProducer p1 = clientSession.createProducer(queueName);
      ClientConsumer c = clientSession.createConsumer(queueName);
      ClientConsumer c1 = clientSession.createConsumer(queueName);
      clientSession.close();
      assertTrue(clientSession.isClosed());
      assertTrue(p.isClosed());
      assertTrue(p1.isClosed());
      assertTrue(c.isClosed());
      assertTrue(c1.isClosed());
   }

   @TestTemplate
   public void testCreateMessageNonDurable() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      ClientMessage clientMessage = clientSession.createMessage(false);
      assertFalse(clientMessage.isDurable());
      clientSession.close();
   }

   @TestTemplate
   public void testCreateMessageDurable() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      ClientMessage clientMessage = clientSession.createMessage(true);
      assertTrue(clientMessage.isDurable());
      clientSession.close();
   }

   @TestTemplate
   public void testCreateMessageType() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      ClientMessage clientMessage = clientSession.createMessage((byte) 99, false);
      assertEquals((byte) 99, clientMessage.getType());
      clientSession.close();
   }

   @TestTemplate
   public void testCreateMessageOverrides() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      ClientMessage clientMessage = clientSession.createMessage((byte) 88, false, 100L, 300L, (byte) 33);
      assertEquals((byte) 88, clientMessage.getType());
      assertEquals(100L, clientMessage.getExpiration());
      assertEquals(300L, clientMessage.getTimestamp());
      assertEquals((byte) 33, clientMessage.getPriority());
      clientSession.close();
   }

   @TestTemplate
   public void testGetVersion() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      assertEquals(server.getVersion().getIncrementingVersion(), clientSession.getVersion());
      clientSession.close();
   }

   @TestTemplate
   public void testStart() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      clientSession.start();
      clientSession.close();
   }

   @TestTemplate
   public void testStop() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, true, true);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      clientSession.start();
      clientSession.stop();
      clientSession.close();
   }

   @TestTemplate
   public void testCommitWithSend() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, false, true);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      ClientProducer cp = clientSession.createProducer(queueName);
      for (int i = 0; i < 10; i++) {
         cp.send(clientSession.createMessage(false));
      }
      Queue q = (Queue) server.getPostOffice().getBinding(SimpleString.of(queueName)).getBindable();
      Wait.assertEquals(0, () -> getMessageCount(q));
      clientSession.commit();
      assertTrue(Wait.waitFor(() -> getMessageCount(q) == 10, 2000, 100));
      clientSession.close();
   }

   @TestTemplate
   public void testRollbackWithSend() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = cf.createSession(false, false, true);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      ClientProducer cp = clientSession.createProducer(queueName);
      for (int i = 0; i < 10; i++) {
         cp.send(clientSession.createMessage(false));
      }
      Queue q = (Queue) server.getPostOffice().getBinding(SimpleString.of(queueName)).getBindable();
      Wait.assertEquals(0, () -> getMessageCount(q));
      clientSession.rollback();
      cp.send(clientSession.createMessage(false));
      cp.send(clientSession.createMessage(false));
      clientSession.commit();
      Wait.assertEquals(2, () -> getMessageCount(q));
      clientSession.close();
   }

   @TestTemplate
   public void testCommitWithReceive() throws Exception {
      locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);
      cf = createSessionFactory(locator);
      ClientSession sendSession = cf.createSession(false, true, true);
      ClientProducer cp = sendSession.createProducer(queueName);
      ClientSession clientSession = cf.createSession(false, true, false);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      for (int i = 0; i < 10; i++) {
         cp.send(clientSession.createMessage(false));
      }
      Queue q = (Queue) server.getPostOffice().getBinding(SimpleString.of(queueName)).getBindable();
      Wait.assertEquals(10, () -> getMessageCount(q));
      ClientConsumer cc = clientSession.createConsumer(queueName);
      clientSession.start();

      for (int i = 0; i < 10; i++) {
         ClientMessage m = cc.receive(5000);
         assertNotNull(m);
         m.acknowledge();
      }
      clientSession.commit();
      assertNull(cc.receiveImmediate());
      Wait.assertEquals(0, () -> getMessageCount(q));
      clientSession.close();
      sendSession.close();
   }

   @TestTemplate
   public void testRollbackWithReceive() throws Exception {
      locator.setBlockOnNonDurableSend(true).setBlockOnDurableSend(true);
      cf = createSessionFactory(locator);
      ClientSession sendSession = cf.createSession(false, true, true);
      ClientProducer cp = sendSession.createProducer(queueName);
      ClientSession clientSession = cf.createSession(false, true, false);
      if (legacyCreateQueue) {
         clientSession.createQueue(queueName, queueName, false);
      } else {
         clientSession.createQueue(QueueConfiguration.of(queueName).setDurable(false));
      }
      for (int i = 0; i < 10; i++) {
         cp.send(clientSession.createMessage(false));
      }
      Queue q = (Queue) server.getPostOffice().getBinding(SimpleString.of(queueName)).getBindable();
      Wait.assertEquals(10, () -> getMessageCount(q));
      ClientConsumer cc = clientSession.createConsumer(queueName);
      clientSession.start();
      for (int i = 0; i < 10; i++) {
         ClientMessage m = cc.receive(5000);
         assertNotNull(m);
         m.acknowledge();
      }
      Wait.assertEquals(10, () -> getMessageCount(q));
      clientSession.close();
      sendSession.close();
   }

   @TestTemplate
   public void testGetNodeId() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = addClientSession(cf.createSession(false, true, true));
      String nodeId = ((ClientSessionInternal) clientSession).getNodeId();
      assertNotNull(nodeId);
   }

   @TestTemplate
   public void testCreateQueue() throws Exception {
      cf = createSessionFactory(locator);
      ClientSession clientSession = addClientSession(cf.createSession(false, true, true));
      SimpleString queueName = SimpleString.of(UUID.randomUUID().toString());
      SimpleString addressName = SimpleString.of(UUID.randomUUID().toString());
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName, RoutingType.ANYCAST, queueName);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName.toString(), RoutingType.ANYCAST, queueName.toString());
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName, RoutingType.ANYCAST, queueName, true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertTrue(result.isDurable());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName.toString(), RoutingType.ANYCAST, queueName.toString(), true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertTrue(result.isDurable());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName, RoutingType.ANYCAST, queueName, SimpleString.of("filter"), true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter"));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName.toString(), RoutingType.ANYCAST, queueName.toString(), "filter", true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter"));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName, RoutingType.ANYCAST, queueName, SimpleString.of("filter"), true, true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter").setAutoCreated(true));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         assertTrue(result.isAutoCreated());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName.toString(), RoutingType.ANYCAST, queueName.toString(), "filter", true, true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter").setAutoCreated(true));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         assertTrue(result.isAutoCreated());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName, RoutingType.ANYCAST, queueName, SimpleString.of("filter"), true, true, 0, true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter").setAutoCreated(true).setMaxConsumers(0).setPurgeOnNoConsumers(true));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         assertTrue(result.isAutoCreated());
         assertEquals(0, result.getMaxConsumers());
         assertTrue(result.isPurgeOnNoConsumers());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName.toString(), RoutingType.ANYCAST, queueName.toString(), "filter", true, true, 0, true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter").setAutoCreated(true).setMaxConsumers(0).setPurgeOnNoConsumers(true));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         assertTrue(result.isAutoCreated());
         assertEquals(0, result.getMaxConsumers());
         assertTrue(result.isPurgeOnNoConsumers());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName, RoutingType.ANYCAST, queueName, SimpleString.of("filter"), true, true, 0, true, true, true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter").setAutoCreated(true).setMaxConsumers(0).setPurgeOnNoConsumers(true).setExclusive(true).setLastValue(true));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         assertTrue(result.isAutoCreated());
         assertEquals(0, result.getMaxConsumers());
         assertTrue(result.isPurgeOnNoConsumers());
         assertTrue(result.isExclusive());
         assertTrue(result.isLastValue());
         server.destroyQueue(queueName);
      }
      {
         if (legacyCreateQueue) {
            clientSession.createQueue(addressName.toString(), RoutingType.ANYCAST, queueName.toString(), "filter", true, true, 0, true, true, true);
         } else {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter").setAutoCreated(true).setMaxConsumers(0).setPurgeOnNoConsumers(true).setExclusive(true).setLastValue(true));
         }
         Queue result = server.locateQueue(queueName);
         assertEquals(addressName, result.getAddress());
         assertEquals(queueName, result.getName());
         assertEquals(RoutingType.ANYCAST, result.getRoutingType());
         assertEquals("filter", result.getFilter().getFilterString().toString());
         assertTrue(result.isDurable());
         assertTrue(result.isAutoCreated());
         assertEquals(0, result.getMaxConsumers());
         assertTrue(result.isPurgeOnNoConsumers());
         assertTrue(result.isExclusive());
         assertTrue(result.isLastValue());
         assertTrue(result.isEnabled());
         server.destroyQueue(queueName);
      }
      {
         if (!legacyCreateQueue) {
            clientSession.createQueue(QueueConfiguration.of(queueName).setAddress(addressName).setRoutingType(RoutingType.ANYCAST).setFilterString("filter").setAutoCreated(true).setMaxConsumers(0).setPurgeOnNoConsumers(true).setExclusive(true).setLastValue(true).setEnabled(false));
            Queue result = server.locateQueue(queueName);
            assertEquals(addressName, result.getAddress());
            assertEquals(queueName, result.getName());
            assertEquals(RoutingType.ANYCAST, result.getRoutingType());
            assertEquals("filter", result.getFilter().getFilterString().toString());
            assertTrue(result.isDurable());
            assertTrue(result.isAutoCreated());
            assertEquals(0, result.getMaxConsumers());
            assertTrue(result.isPurgeOnNoConsumers());
            assertTrue(result.isExclusive());
            assertTrue(result.isLastValue());
            assertFalse(result.isEnabled());
            server.destroyQueue(queueName);
         }

      }
   }
}
