public void testWithConnection() throws JMSException {
    MockControl conControl = MockControl.createControl(Connection.class);
    Connection con = (Connection) conControl.getMock();

    con.start();
    conControl.setVoidCallable(1);
    con.stop();
    conControl.setVoidCallable(1);
    con.close();
    conControl.setVoidCallable(1);

    conControl.replay();

    SingleConnectionFactory scf = new SingleConnectionFactory(con);
    Connection con1 = scf.createConnection();
    con1.start();
    con1.stop(); // should be ignored
    con1.close(); // should be ignored
    Connection con2 = scf.createConnection();
    con2.start(); // should be ignored
    con2.stop(); // should be ignored
    con2.close(); // should be ignored
    scf.destroy(); // should trigger actual close

    conControl.verify();
  }
  public void testWithConnectionFactoryAndClientId() throws JMSException {
    MockControl cfControl = MockControl.createControl(ConnectionFactory.class);
    ConnectionFactory cf = (ConnectionFactory) cfControl.getMock();
    MockControl conControl = MockControl.createControl(Connection.class);
    Connection con = (Connection) conControl.getMock();

    cf.createConnection();
    cfControl.setReturnValue(con, 1);
    con.setClientID("myId");
    conControl.setVoidCallable(1);
    con.start();
    conControl.setVoidCallable(1);
    con.stop();
    conControl.setVoidCallable(1);
    con.close();
    conControl.setVoidCallable(1);

    cfControl.replay();
    conControl.replay();

    SingleConnectionFactory scf = new SingleConnectionFactory(cf);
    scf.setClientId("myId");
    Connection con1 = scf.createConnection();
    con1.start();
    con1.close(); // should be ignored
    Connection con2 = scf.createConnection();
    con2.start();
    con2.close(); // should be ignored
    scf.destroy(); // should trigger actual close

    cfControl.verify();
    conControl.verify();
  }
  /**
   * Send a command via JMS.
   *
   * <p>Note: Opens and closes the connection per invocation of this method which, when run outside
   * a JavaEE container, is not very efficient.
   *
   * @param command
   * @throws JMSException
   */
  public void sendCommandMessage(Command command) throws JMSException {
    Connection connection = null;
    Session session = null;
    try {
      connection = connectionFactory.createConnection();
      session = connection.createSession(TRANSACTIONAL, Session.AUTO_ACKNOWLEDGE);

      // Construct a JMS "TextMessage"
      final TextMessage newMessage = session.createTextMessage();
      newMessage.setStringProperty("issuer", command.getIssuer());
      newMessage.setStringProperty("type", command.getType());
      newMessage.setText(command.getPayload());

      // Send the message
      final MessageProducer producer = session.createProducer(this.commandQueue);
      producer.send(newMessage);

      if (TRANSACTIONAL) {
        // JavaEE containers would manage this
        session.commit();
      }
    } finally {
      if (connection != null) {
        try {
          if (session != null) {
            session.close();
          }
          connection.stop();
          connection.close();
        } catch (JMSException e) {
          e.printStackTrace();
        }
      }
    }
  }
  @Override
  @Test(timeout = 30000)
  public void testMessageSizeTwoDurables() throws Exception {
    AtomicLong publishedMessageSize = new AtomicLong();

    Connection connection = new ActiveMQConnectionFactory(brokerConnectURI).createConnection();
    connection.setClientID("clientId");
    connection.start();

    org.apache.activemq.broker.region.Topic dest =
        publishTestMessagesDurable(
            connection,
            new String[] {"sub1", "sub2"},
            200,
            publishedMessageSize,
            DeliveryMode.PERSISTENT);

    // verify the count and size
    SubscriptionKey subKey = new SubscriptionKey("clientId", "sub1");
    verifyPendingStats(dest, subKey, 200, publishedMessageSize.get());

    // consume messages just for sub1
    consumeDurableTestMessages(connection, "sub1", 200, publishedMessageSize);

    // There is still a durable that hasn't consumed so the messages should exist
    SubscriptionKey subKey2 = new SubscriptionKey("clientId", "sub2");
    verifyPendingStats(dest, subKey, 0, 0);
    verifyPendingStats(dest, subKey2, 200, publishedMessageSize.get());

    // The expected value is only 100 because for durables a LRUCache is being used
    // with a max size of 100
    verifyStoreStats(dest, 100, publishedMessageSize.get());

    connection.stop();
  }
  @Test
  public void testSendMessage() throws Exception {
    ConnectionFactory connFactory = lookup("ConnectionFactory", ConnectionFactory.class);
    Connection conn = connFactory.createConnection();
    conn.start();
    Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    TemporaryQueue replyQueue = session.createTemporaryQueue();
    TextMessage msg = session.createTextMessage("Hello world");
    msg.setJMSDeliveryMode(DeliveryMode.NON_PERSISTENT);
    msg.setJMSReplyTo(replyQueue);
    Queue queue = lookup("java:jboss/" + queueName, Queue.class);
    MessageProducer producer = session.createProducer(queue);
    producer.send(msg);
    MessageConsumer consumer = session.createConsumer(replyQueue);
    Message replyMsg = consumer.receive(5000);
    Assert.assertNotNull(replyMsg);
    if (replyMsg instanceof ObjectMessage) {
      Exception e = (Exception) ((ObjectMessage) replyMsg).getObject();
      throw e;
    }
    Assert.assertTrue(replyMsg instanceof TextMessage);
    String actual = ((TextMessage) replyMsg).getText();
    Assert.assertEquals("SUCCESS", actual);

    consumer.close();
    producer.close();
    session.close();
    conn.stop();
  }
示例#6
0
 @Override
 public void stop() {
   try {
     messageConsumer.close();
     connection.stop();
   } catch (JMSException e) {
     e.printStackTrace();
   }
 }
示例#7
0
 private void shutdown() {
   try {
     _session.close();
     _connection.stop();
     _connection.close();
   } catch (Exception e) {
     e.printStackTrace(System.out);
   }
 }
示例#8
0
  @Test
  public void testAdminConnection() throws Exception {
    Assert.assertEquals(2, BROKERS.size());

    // ConnectionFactory factory =  new
    // ActiveMQConnectionFactory(BrokerRegistry.getInstance().findFirst().getVmConnectorURI());
    ConnectionFactory fc = new ActiveMQConnectionFactory("tcp://*****:*****@EU", "password");
    consumerConnection.start();
    Connection producerConnection = fp.createConnection("system@EU", "password");
    producerConnection.start();
    Session consumerSession = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageConsumer consumer =
        consumerSession.createConsumer(consumerSession.createTopic(ADMIN_TOPIC));
    MessageProducer producer =
        producerSession.createProducer(producerSession.createTopic(ADMIN_TOPIC));

    final CountDownLatch messageSignal = new CountDownLatch(1);
    consumer.setMessageListener(
        new MessageListener() {
          @Override
          public void onMessage(javax.jms.Message message) {
            try {
              LOG.info(
                  "Received admin message {} with content: \"{}\".",
                  message.getJMSMessageID().toString(),
                  ((ActiveMQTextMessage) message).getText());
              messageSignal.countDown();
            } catch (JMSException e) {
              e.printStackTrace();
            }
          }
        });

    Thread.sleep(200);
    producer.send(producerSession.createTextMessage("QQQ: $1000.00"));
    messageSignal.await(1000, TimeUnit.MILLISECONDS);
    Assert.assertEquals(0, messageSignal.getCount());

    producerConnection.stop();
    consumerConnection.stop();
  }
  /**
   * Send some messages. Receive them in a transacted session. Commit the receiving session Close
   * the connection Create a new connection, session and consumer - verify messages are not
   * redelivered
   */
  @Test
  public void testAckCommitQueue() throws Exception {
    Connection conn = null;

    try {
      conn = createConnection();

      Session producerSess = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
      MessageProducer producer = producerSess.createProducer(queue1);

      Session consumerSess = conn.createSession(true, Session.SESSION_TRANSACTED);
      MessageConsumer consumer = consumerSess.createConsumer(queue1);
      conn.start();

      final int NUM_MESSAGES = 10;

      // Send some messages
      for (int i = 0; i < NUM_MESSAGES; i++) {
        Message m = producerSess.createMessage();
        producer.send(m);
      }

      int count = 0;
      while (true) {
        Message m = consumer.receive(500);
        if (m == null) {
          break;
        }
        count++;
      }

      ProxyAssertSupport.assertEquals(NUM_MESSAGES, count);

      consumerSess.commit();

      conn.stop();
      consumer.close();

      conn.close();

      conn = createConnection();

      consumerSess = conn.createSession(true, Session.CLIENT_ACKNOWLEDGE);
      consumer = consumerSess.createConsumer(queue1);
      conn.start();

      Message m = consumer.receive(500);

      ProxyAssertSupport.assertNull(m);
    } finally {
      if (conn != null) {
        conn.close();
      }
    }
  }
示例#10
0
  @Test
  public void testAuthWithMultipleTransports() throws Exception {
    Assert.assertEquals(2, BROKERS.size());

    ConnectionFactory fc = new ActiveMQConnectionFactory("tcp://localhost:62616");
    ConnectionFactory fp = new ActiveMQConnectionFactory("tcp://localhost:61616");
    Connection consumerConnection = fc.createConnection();
    consumerConnection.start();
    Connection producerConnection = fp.createConnection();
    producerConnection.start();
    Session consumerSession = consumerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    Session producerSession = producerConnection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageConsumer consumer =
        consumerSession.createConsumer(consumerSession.createQueue(DEFAULT_QUEUE));
    MessageProducer producer =
        producerSession.createProducer(producerSession.createQueue(DEFAULT_QUEUE));

    final CountDownLatch messageSignal = new CountDownLatch(1);
    consumer.setMessageListener(
        new MessageListener() {
          @Override
          public void onMessage(javax.jms.Message message) {
            try {
              LOG.info(
                  "Received forwarded message {} with content: \"{}\".",
                  message.getJMSMessageID().toString(),
                  ((ActiveMQTextMessage) message).getText());
              messageSignal.countDown();
            } catch (JMSException e) {
              e.printStackTrace();
            }
          }
        });

    Thread.sleep(200);
    producer.send(producerSession.createTextMessage("QQQ: $1000.00"));
    messageSignal.await(1000, TimeUnit.MILLISECONDS);
    Assert.assertEquals(0, messageSignal.getCount());

    producerConnection.stop();
    consumerConnection.stop();
  }
 /** Interrompe la connessione con la destinazione JMS */
 protected void stopReceiveMessages() {
   if (this.receiving) {
     try {
       connection.stop();
       this.receiving = false;
     } catch (JMSException e) {
       System.out.println("JMSChatSubscriber: " + e.toString());
       System.exit(1);
     }
   }
 }
 @AfterMethod
 public void shutdownConnection() throws Exception {
   for (final Session session : _sessions) {
     session.close();
   }
   _sessions.clear();
   if (null != _connection) {
     _connection.stop();
     _connection.close();
     _connection = null;
   }
 }
  public void testWithConnectionFactoryAndExceptionListener() throws JMSException {
    MockControl cfControl = MockControl.createControl(ConnectionFactory.class);
    ConnectionFactory cf = (ConnectionFactory) cfControl.getMock();
    MockControl conControl = MockControl.createControl(Connection.class);
    Connection con = (Connection) conControl.getMock();

    ExceptionListener listener = new ChainedExceptionListener();
    cf.createConnection();
    cfControl.setReturnValue(con, 1);
    con.setExceptionListener(listener);
    conControl.setVoidCallable(1);
    con.getExceptionListener();
    conControl.setReturnValue(listener, 1);
    con.start();
    conControl.setVoidCallable(1);
    con.stop();
    conControl.setVoidCallable(1);
    con.close();
    conControl.setVoidCallable(1);

    cfControl.replay();
    conControl.replay();

    SingleConnectionFactory scf = new SingleConnectionFactory(cf);
    scf.setExceptionListener(listener);
    Connection con1 = scf.createConnection();
    assertEquals(listener, con1.getExceptionListener());
    con1.start();
    con1.stop(); // should be ignored
    con1.close(); // should be ignored
    Connection con2 = scf.createConnection();
    con2.start();
    con2.stop(); // should be ignored
    con2.close(); // should be ignored
    scf.destroy(); // should trigger actual close

    cfControl.verify();
    conControl.verify();
  }
示例#14
0
 /**
  * close() will stop the connection first. Then it closes the subscriber, session and connection.
  */
 public void close() { // called from threadFinished() thread
   log.debug("close()");
   try {
     if (CONN != null) {
       CONN.stop();
     }
   } catch (JMSException e) {
     log.error(e.getMessage());
   }
   Utils.close(SUBSCRIBER, log);
   Utils.close(SESSION, log);
   Utils.close(CONN, log);
 }
示例#15
0
  public synchronized void pause() throws Exception {
    if (JMSBridgeImpl.trace) {
      HornetQJMSServerLogger.LOGGER.trace("Pausing " + this);
    }

    synchronized (lock) {
      paused = true;

      sourceConn.stop();
    }

    if (JMSBridgeImpl.trace) {
      HornetQJMSServerLogger.LOGGER.trace("Paused " + this);
    }
  }
示例#16
0
  public static void main(String[] args) throws Exception {
    InitialContext ctx = new InitialContext();
    connectionFactory = (ConnectionFactory) ctx.lookup(args[0]);
    queue = (Queue) ctx.lookup(args[1]);

    Connection connection = connectionFactory.createConnection();
    Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageConsumer consumer = session.createConsumer((Destination) queue);
    connection.start();
    TextMessage message = (TextMessage) consumer.receive();
    System.out.println("Recebido: " + message.getText());
    session.close();
    connection.stop();
    connection.close();
    System.exit(0);
  }
示例#17
0
  private void cleanup() {
    // Stop the source connection
    try {
      sourceConn.stop();
    } catch (Throwable ignore) {
      if (JMSBridgeImpl.trace) {
        HornetQJMSServerLogger.LOGGER.trace("Failed to stop source connection", ignore);
      }
    }

    if (tx != null) {
      try {
        delistResources(tx);
      } catch (Throwable ignore) {
        if (JMSBridgeImpl.trace) {
          HornetQJMSServerLogger.LOGGER.trace("Failed to delist resources", ignore);
        }
      }
      try {
        // Terminate the tx
        tx.rollback();
      } catch (Throwable ignore) {
        if (JMSBridgeImpl.trace) {
          HornetQJMSServerLogger.LOGGER.trace("Failed to rollback", ignore);
        }
      }
    }

    // Close the old objects
    try {
      sourceConn.close();
    } catch (Throwable ignore) {
      if (JMSBridgeImpl.trace) {
        HornetQJMSServerLogger.LOGGER.trace("Failed to close source connection", ignore);
      }
    }
    try {
      if (targetConn != null) {
        targetConn.close();
      }
    } catch (Throwable ignore) {
      if (JMSBridgeImpl.trace) {
        HornetQJMSServerLogger.LOGGER.trace("Failed to close target connection", ignore);
      }
    }
  }
 /**
  * Release the given Connection, stopping it (if necessary) and eventually closing it.
  *
  * <p>Checks {@link SmartConnectionFactory#shouldStop}, if available. This is essentially a more
  * sophisticated version of {@link org.springframework.jms.support.JmsUtils#closeConnection}.
  *
  * @param con the Connection to release (if this is {@code null}, the call will be ignored)
  * @param cf the ConnectionFactory that the Connection was obtained from (may be {@code null})
  * @param started whether the Connection might have been started by the application
  * @see SmartConnectionFactory#shouldStop
  * @see org.springframework.jms.support.JmsUtils#closeConnection
  */
 public static void releaseConnection(Connection con, ConnectionFactory cf, boolean started) {
   if (con == null) {
     return;
   }
   if (started
       && cf instanceof SmartConnectionFactory
       && ((SmartConnectionFactory) cf).shouldStop(con)) {
     try {
       con.stop();
     } catch (Throwable ex) {
       logger.debug("Could not stop JMS Connection before closing it", ex);
     }
   }
   try {
     con.close();
   } catch (Throwable ex) {
     logger.debug("Could not close JMS Connection", ex);
   }
 }
示例#19
0
  public void stop() {
    if (this.tempdispatcher.size() > 0) {
      for (ReceiveDispatcher dispatcher : this.tempdispatcher) {
        try {
          dispatcher.stop();
        } catch (Exception e) {
          e.printStackTrace();
        }
      }
    }
    if (this.requestDispatcher != null) {
      this.requestDispatcher.stop();
    }
    //      if(this.responseDispatcher != null)
    //      {
    //          this.responseDispatcher.stop();
    //      }
    if (this.connection != null)
      try {
        connection.stop();

      } catch (Exception e) {
        e.printStackTrace();
      }
    //            try
    //            {
    //
    //                connection.setClientID(null);
    //            }
    //            catch(Exception e)
    //            {
    //                e.printStackTrace();
    //            }

    try {

      this.connection.close();
    } catch (JMSException e) {
      e.printStackTrace();
    }
  }
  @Test
  public void testServer() throws Exception {
    // BrokerService broker = BrokerFactory
    // .createBroker(JMSServer.BROKER_CLIENT);
    ActiveMQTopic topic = new ActiveMQTopic("topicTest");
    // broker.setDestinations(new ActiveMQDestination[] { topic });
    // broker.start();

    ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(JMSServer.BROKER_CLIENT);
    Connection conn = factory.createConnection();
    conn.start();
    Session session = conn.createSession(false, Session.AUTO_ACKNOWLEDGE);
    MessageProducer producer = session.createProducer(topic);
    producer.send(session.createObjectMessage("msg test 1"));
    producer.send(session.createObjectMessage("msg test 2"));
    producer.send(session.createObjectMessage("msg test 3"));
    producer.send(session.createObjectMessage("msg test 4"));
    session.close();
    conn.stop();
    conn.close();
  }
  protected String doStartAsyncReceiving(Consumer<M> objConsumer, String messageSelector)
      throws DataStreamInfrastructureException {
    String receivingConsumerId = UUID.randomUUID().toString();

    try {
      Connection connection = getConnection();
      connection.stop();
      try {
        Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
        MessageConsumer consumer = session.createConsumer(destination, messageSelector);
        consumer.setMessageListener(message -> objConsumer.accept(convert(message)));
        receivingConsumers.put(receivingConsumerId, new DoubleValueBean<>(session, consumer));
      } finally {
        connection.start();
      }

      return receivingConsumerId;
    } catch (JMSException e) {
      throw new DataStreamInfrastructureException(e);
    }
  }
	/**
	 * Close the given Connection.
	 * @param con the Connection to close
	 */
	protected void closeConnection(Connection con) {
		if (logger.isDebugEnabled()) {
			logger.debug("Closing shared JMS Connection: " + this.target);
		}
		try {
			try {
				if (this.started) {
					this.started = false;
					con.stop();
				}
			}
			finally {
				con.close();
			}
		}
		catch (javax.jms.IllegalStateException ex) {
			logger.debug("Ignoring Connection state exception - assuming already closed: " + ex);
		}
		catch (Throwable ex) {
			logger.debug("Could not close shared JMS Connection", ex);
		}
	}
示例#23
0
 /**
  * Close the given JMS Connection and ignore any thrown exception. This is useful for typical
  * <code>finally</code> blocks in manual JMS code.
  *
  * @param con the JMS Connection to close (may be <code>null</code>)
  * @param stop whether to call <code>stop()</code> before closing
  */
 public static void closeConnection(Connection con, boolean stop) {
   if (con != null) {
     try {
       if (stop) {
         try {
           con.stop();
         } finally {
           con.close();
         }
       } else {
         con.close();
       }
     } catch (javax.jms.IllegalStateException ex) {
       logger.debug("Ignoring Connection state exception - assuming already closed: " + ex);
     } catch (JMSException ex) {
       logger.debug("Could not close JMS Connection", ex);
     } catch (Throwable ex) {
       // We don't trust the JMS provider: It might throw RuntimeException or Error.
       logger.debug("Unexpected exception on closing JMS Connection", ex);
     }
   }
 }
示例#24
0
  private void run() throws Exception {
    ActiveMQConnectionFactory factory = new ActiveMQConnectionFactory(url);
    connection = factory.createConnection();
    session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);
    topic = session.createTopic("topictest.messages");
    control = session.createTopic("topictest.control");

    publisher = session.createProducer(topic);
    publisher.setDeliveryMode(DeliveryMode.NON_PERSISTENT);

    payload = new byte[size];
    for (int i = 0; i < size; i++) {
      payload[i] = (byte) DATA[i % DATA.length];
    }

    session.createConsumer(control).setMessageListener(this);
    connection.start();

    long[] times = new long[batch];
    for (int i = 0; i < batch; i++) {
      if (i > 0) {
        Thread.sleep(delay * 1000);
      }
      times[i] = batch(messages);
      System.out.println(
          "Batch " + (i + 1) + " of " + batch + " completed in " + times[i] + " ms.");
    }

    long min = min(times);
    long max = max(times);
    System.out.println("min: " + min + ", max: " + max + " avg: " + avg(times, min, max));

    // request shutdown
    publisher.send(session.createTextMessage("SHUTDOWN"));

    connection.stop();
    connection.close();
  }
 @Override
 protected void tearDown() throws Exception {
   connection.stop();
   broker.stop();
   broker.waitUntilStopped();
 }
 public void stop() throws JMSException, InterruptedException {
   running = false;
   if (connection != null) {
     connection.stop();
   }
 }
示例#27
0
 /**
  * Should be called after local messaging operations are finished to save resources
  *
  * @throws JMSException
  */
 public void stopConnection() throws JMSException {
   connection.stop();
 }
示例#28
0
 /**
  * Calls Connection.stop() to stop receiving inbound messages.
  *
  * @throws JMSException
  */
 public void stop() throws JMSException {
   log.debug("stop()");
   CONN.stop();
 }
示例#29
0
  /**
   * {@inheritDoc}
   *
   * @throws java.lang.Exception
   */
  protected void stop() throws Exception {

    LOG.info("Stopping connection");
    connection.stop();
  }
  public void testCachingConnectionFactory() throws JMSException {
    MockControl cfControl = MockControl.createControl(ConnectionFactory.class);
    ConnectionFactory cf = (ConnectionFactory) cfControl.getMock();
    MockControl conControl = MockControl.createControl(Connection.class);
    Connection con = (Connection) conControl.getMock();
    MockControl txSessionControl = MockControl.createControl(Session.class);
    Session txSession = (Session) txSessionControl.getMock();
    MockControl nonTxSessionControl = MockControl.createControl(Session.class);
    Session nonTxSession = (Session) nonTxSessionControl.getMock();

    cf.createConnection();
    cfControl.setReturnValue(con, 1);
    con.createSession(true, Session.AUTO_ACKNOWLEDGE);
    conControl.setReturnValue(txSession, 1);
    txSession.getTransacted();
    txSessionControl.setReturnValue(true, 1);
    txSession.commit();
    txSessionControl.setVoidCallable(1);
    txSession.close();
    txSessionControl.setVoidCallable(1);
    con.createSession(false, Session.CLIENT_ACKNOWLEDGE);
    conControl.setReturnValue(nonTxSession, 1);
    nonTxSession.close();
    nonTxSessionControl.setVoidCallable(1);
    con.start();
    conControl.setVoidCallable(1);
    con.stop();
    conControl.setVoidCallable(1);
    con.close();
    conControl.setVoidCallable(1);

    cfControl.replay();
    conControl.replay();
    txSessionControl.replay();
    nonTxSessionControl.replay();

    CachingConnectionFactory scf = new CachingConnectionFactory(cf);
    scf.setReconnectOnException(false);
    Connection con1 = scf.createConnection();
    Session session1 = con1.createSession(true, Session.AUTO_ACKNOWLEDGE);
    session1.getTransacted();
    session1.close(); // should lead to rollback
    session1 = con1.createSession(false, Session.CLIENT_ACKNOWLEDGE);
    session1.close(); // should be ignored
    con1.start();
    con1.close(); // should be ignored
    Connection con2 = scf.createConnection();
    Session session2 = con2.createSession(false, Session.CLIENT_ACKNOWLEDGE);
    session2.close(); // should be ignored
    session2 = con2.createSession(true, Session.AUTO_ACKNOWLEDGE);
    session2.commit();
    session2.close(); // should be ignored
    con2.start();
    con2.close(); // should be ignored
    scf.destroy(); // should trigger actual close

    cfControl.verify();
    conControl.verify();
    txSessionControl.verify();
    nonTxSessionControl.verify();
  }