JMSTestModule (MockRunner-JMS 1.1.2 API)

java.lang.Object
- com.mockrunner.jms.JMSTestModule

```
public class JMSTestModule
extends Object
```
Module for JMS tests. Note that all indices are zero based.
Note for JMS 1.1: If you use MockQueueConnectionFactory for creating your connections and sessions, you have to use the methods with Queue in their name. Same with MockTopicConnectionFactory. The methods without Queue and Topic in the method name are for connections and sessions that were created using the MockConnectionFactory. MockConnectionFactory also implements the QueueConnectionFactory and TopicConnectionFactory interfaces and can be used to create queue and topic connections as well as generic JMS 1.1 connections. It is recommended to use MockQueueConnectionFactory if you only use queues and MockTopicConnectionFactory if you only use topics and are not interested in having one factory for both. It is possible to create a MockQueueConnection or a MockTopicConnection using the MockConnectionFactory. However, the Queue methods (e.g. verifyAllQueueReceiversClosed(int)) only work, if you use MockQueueConnectionFactory and the Topic methods (e.g. verifyCreatedTopicMapMessageNotAcknowledged(int, int)) only work, if you use MockTopicConnectionFactory.

Constructor Summary

Constructors
Constructor and Description

JMSTestModule(JMSMockObjectFactory mockFactory)

Constructors
Constructor and Description
`JMSTestModule(JMSMockObjectFactory mockFactory)`

Method Summary

Methods
Modifier and Type	Method and Description
`ConfigurationManager`	`getConfigurationManager()` Returns the `ConfigurationManager`.
`MockConnection`	`getCurrentConnection()` Returns the current `MockConnection` based on its index or `null` if no connection was created.
`List`	`getCurrentMessageListFromQueue(String name)` Returns the list of messages that are currently present in the queue or `null` if no such queue exists.
`List`	`getCurrentMessageListFromTemporaryQueue(int indexOfSession, int indexOfQueue)` Returns the list of messages that are currently present in the temporary queue or `null` if no such queue exists.
`List`	`getCurrentMessageListFromTemporaryTopic(int indexOfSession, int indexOfTopic)` Returns the list of messages that are currently present in the temporary topic or `null` if no such topic exists.
`List`	`getCurrentMessageListFromTopic(String name)` Returns the list of messages that are currently present in the topic or `null` if no such topic exists.
`MockQueueConnection`	`getCurrentQueueConnection()` Returns the current `MockQueueConnection` based on its index or `null` if no queue connection was created.
`MockTopicConnection`	`getCurrentTopicConnection()` Returns the current `MockTopicConnection` based on its index or `null` if no topic connection was created.
`DestinationManager`	`getDestinationManager()` Returns the `DestinationManager`.
`MessageManager`	`getMessageManager(int indexOfSession)` Returns the `MessageManager` for the specified session or `null` if the session does not exist.
`MockQueue`	`getQueue(String name)` Returns the `MockQueue` with the specified name or `null` if no such queue exists.
`MessageManager`	`getQueueMessageManager(int indexOfSession)` Returns the `MessageManager` for the specified session or `null` if the session does not exist.
`MockQueueSession`	`getQueueSession(int indexOfSession)` Returns the `MockQueueSession` for the specified index or `null` if the session does not exist.
`List`	`getQueueSessionList()` Returns the list of `MockQueueSession` objects.
`QueueTransmissionManager`	`getQueueTransmissionManager(int indexOfSession)` Returns the `QueueTransmissionManager` for the specified session or `null` if the session does not exist.
`TransmissionManagerWrapper`	`getQueueTransmissionManagerWrapper(int indexOfSession)` Returns the `TransmissionManagerWrapper` for the specified session or `null` if the session does not exist.
`List`	`getReceivedMessageListFromQueue(String name)` Returns the list of messages that were received by the queue or `null` if no such queue exists.
`List`	`getReceivedMessageListFromTemporaryQueue(int indexOfSession, int indexOfQueue)` Returns the list of messages that were received by the temporary queue or `null` if no such queue exists.
`List`	`getReceivedMessageListFromTemporaryTopic(int indexOfSession, int indexOfTopic)` Returns the list of messages that were received by the temporary topic or `null` if no such topic exists.
`List`	`getReceivedMessageListFromTopic(String name)` Returns the list of messages that were received by the topic or `null` if no such topic exists.
`MockSession`	`getSession(int indexOfSession)` Returns the `MockSession` for the specified index or `null` if the session does not exist.
`List`	`getSessionList()` Returns the list of `MockSession` objects.
`MockTemporaryQueue`	`getTemporaryQueue(int indexOfSession, int indexOfQueue)` Returns the `MockTemporaryQueue` with the specified index for the specified session.
`List`	`getTemporaryQueueList(int indexOfSession)` Returns the list of `MockTemporaryQueue` objects for the specified session.
`MockTemporaryTopic`	`getTemporaryTopic(int indexOfSession, int indexOfTopic)` Returns the `MockTemporaryTopic` with the specified index for the specified session.
`List`	`getTemporaryTopicList(int indexOfSession)` Returns the list of `MockTemporaryTopic` objects for the specified session.
`MockTopic`	`getTopic(String name)` Returns the `MockTopic` with the specified name or `null` if no such topic exists.
`MessageManager`	`getTopicMessageManager(int indexOfSession)` Returns the `MessageManager` for the specified session or `null` if the session does not exist.
`MockTopicSession`	`getTopicSession(int indexOfSession)` Returns the `MockTopicSession` for the specified index or `null` if the session does not exist.
`List`	`getTopicSessionList()` Returns the list of `MockTopicSession` objects.
`TopicTransmissionManager`	`getTopicTransmissionManager(int indexOfSession)` Returns the `TopicTransmissionManager` for the specified session or `null` if the session does not exist.
`TransmissionManagerWrapper`	`getTopicTransmissionManagerWrapper(int indexOfSession)` Returns the `TransmissionManagerWrapper` for the specified session or `null` if the session does not exist.
`TransmissionManagerWrapper`	`getTransmissionManager(int indexOfSession)` Deprecated. use `getTransmissionManagerWrapper(int)`
`TransmissionManagerWrapper`	`getTransmissionManagerWrapper(int indexOfSession)` Returns the `TransmissionManagerWrapper` for the specified session or `null` if the session does not exist.
`void`	`registerTestMessageListenerForQueue(MockConnection connection, String queueName, boolean transacted, int acknowledgeMode, javax.jms.MessageListener listener)` Creates a new session and receiver using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForQueue(MockConnection connection, String queueName, boolean transacted, int acknowledgeMode, String messageSelector, javax.jms.MessageListener listener)` Creates a new session and receiver using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForQueue(MockConnection connection, String queueName, javax.jms.MessageListener listener)` Creates a new session and receiver using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForQueue(String queueName, javax.jms.MessageListener listener)` Creates a new connection and uses it for creating a new session and receiver.
`void`	`registerTestMessageListenerForTopic(MockConnection connection, String topicName, boolean transacted, int acknowledgeMode, javax.jms.MessageListener listener)` Creates a new session and subscriber using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForTopic(MockConnection connection, String topicName, boolean transacted, int acknowledgeMode, String messageSelector, javax.jms.MessageListener listener)` Creates a new session and subscriber using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForTopic(MockConnection connection, String topicName, javax.jms.MessageListener listener)` Creates a new session and subscriber using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForTopic(String topicName, javax.jms.MessageListener listener)` Creates a new connection and uses it for creating a new session and subscriber.
`void`	`setCurrentConnectionIndex(int connectionIndex)` Sets the index of the `MockConnection` that should be used for the current test.
`void`	`setCurrentQueueConnectionIndex(int connectionIndex)` Sets the index of the `MockQueueConnection` that should be used for the current test.
`void`	`setCurrentTopicConnectionIndex(int connectionIndex)` Sets the index of the `MockTopicConnection` that should be used for the current test.
`void`	`verifyAllDurableTopicSubscribersClosed(int indexOfSession)` Verifies that all durable subscribers for the specified session are closed.
`void`	`verifyAllMessageConsumersClosed(int indexOfSession)` Verifies that all consumers for the specified session are closed.
`void`	`verifyAllMessageProducersClosed(int indexOfSession)` Verifies that all producers for the specified session are closed.
`void`	`verifyAllQueueBrowsersClosed(int indexOfSession)` Verifies that all browsers for the specified session are closed.
`void`	`verifyAllQueueReceiversClosed(int indexOfSession)` Verifies that all receivers for the specified session are closed.
`void`	`verifyAllQueueSendersClosed(int indexOfSession)` Verifies that all senders for the specified session are closed.
`void`	`verifyAllQueueSessionsClosed()` Verifies that all queue sessions are closed.
`void`	`verifyAllQueueSessionsCommitted()` Verifies that all queue sessions were commited.
`void`	`verifyAllQueueSessionsRecovered()` Verifies that all queue sessions are recovered.
`void`	`verifyAllQueueSessionsRolledBack()` Verifies that all queue sessions were rolled back.
`void`	`verifyAllReceivedQueueMessagesAcknowledged(int indexOfSession, int indexOfQueue)` Verifies that all received messages of the specified temporary queue are acknowledged.
`void`	`verifyAllReceivedQueueMessagesAcknowledged(String nameOfQueue)` Verifies that all received messages of the specified queue are acknowledged.
`void`	`verifyAllReceivedTopicMessagesAcknowledged(int indexOfSession, int indexOfTopic)` Verifies that all received messages of the specified temporary topic are acknowledged.
`void`	`verifyAllReceivedTopicMessagesAcknowledged(String nameOfTopic)` Verifies that all received messages of the specified topic are acknowledged.
`void`	`verifyAllSessionsClosed()` Verifies that all sessions are closed.
`void`	`verifyAllSessionsCommitted()` Verifies that all sessions were commited.
`void`	`verifyAllSessionsRecovered()` Verifies that all sessions are recovered.
`void`	`verifyAllSessionsRolledBack()` Verifies that all topic sessions were rolled back.
`void`	`verifyAllTemporaryQueuesDeleted(int indexOfSession)` Verifies that all temporary queues were deleted.
`void`	`verifyAllTemporaryTopicsDeleted(int indexOfSession)` Verifies that all temporary topics were deleted.
`void`	`verifyAllTopicPublishersClosed(int indexOfSession)` Verifies that all publishers for the specified session are closed.
`void`	`verifyAllTopicSessionsClosed()` Verifies that all topic sessions are closed.
`void`	`verifyAllTopicSessionsCommitted()` Verifies that all topic sessions were commited.
`void`	`verifyAllTopicSessionsRecovered()` Verifies that all topic sessions are recovered.
`void`	`verifyAllTopicSessionsRolledBack()` Verifies that all topic sessions were rolled back.
`void`	`verifyAllTopicSubscribersClosed(int indexOfSession)` Verifies that all subscribers for the specified session are closed.
`void`	`verifyConnectionClosed()` Verifies that the current `MockConnection` is closed.
`void`	`verifyConnectionStarted()` Verifies that the current `MockConnection` is started.
`void`	`verifyConnectionStopped()` Verifies that the current `MockConnection` is stopped.
`void`	`verifyCreatedBytesMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a bytes message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedBytesMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a bytes message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedMapMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a map message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedMapMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a map message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedObjectMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a object message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedObjectMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a object message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedQueueBytesMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a bytes message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedQueueBytesMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a bytes message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedQueueMapMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a map message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedQueueMapMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a map message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedQueueMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedQueueMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedQueueObjectMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a object message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedQueueObjectMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a object message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedQueueStreamMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a stream message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedQueueStreamMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a stream message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedQueueTextMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a text message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedQueueTextMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a text message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedStreamMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a stream message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedStreamMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a stream message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedTextMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a text message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedTextMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a text message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedTopicBytesMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a bytes message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedTopicBytesMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a bytes message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedTopicMapMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a map message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedTopicMapMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a map message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedTopicMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedTopicMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedTopicObjectMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a object message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedTopicObjectMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a object message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedTopicStreamMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a stream message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedTopicStreamMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a stream message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCreatedTopicTextMessageAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a text message created with `MockSession.createMessage()` is acknowledged.
`void`	`verifyCreatedTopicTextMessageNotAcknowledged(int indexOfSession, int indexOfMessage)` Verifies that a text message created with `MockSession.createMessage()` is not acknowledged.
`void`	`verifyCurrentQueueMessageEquals(int indexOfSession, int indexOfQueue, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a message in the specified temporary queue is equal to the specified message by calling the `equals()` method.
`void`	`verifyCurrentQueueMessageEquals(String nameOfQueue, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a message in the specified queue is equal to the specified message by calling the `equals()` method.
`void`	`verifyCurrentTopicMessageEquals(int indexOfSession, int indexOfTopic, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a message in the specified temporary topic is equal to the specified message by calling the `equals()` method.
`void`	`verifyCurrentTopicMessageEquals(String nameOfTopic, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a message in the specified topic is equal to the specified message by calling the `equals()` method.
`void`	`verifyDurableTopicSubscriberClosed(int indexOfSession, String name)` Verifies that the specified durable subscriber is closed.
`void`	`verifyDurableTopicSubscriberPresent(int indexOfSession, String name)` Verifies that a durable subscriber exists.
`void`	`verifyMessageEquals(MockMessage message1, MockMessage message2)` Verifies that the specified messages are equal by calling the `equals()` method.
`void`	`verifyNumberDurableTopicSubscribers(int indexOfSession, int numberOfSubscribers)` Verifies the number of durable subscribers for the specified session.
`void`	`verifyNumberDurableTopicSubscribers(int indexOfSession, String topicName, int numberOfSubscribers)` Verifies the number of durable subscribers for the specified session and the specified topic name.
`void`	`verifyNumberMessageConsumers(int indexOfSession, int numberOfConsumers)` Verifies the number of consumers for the specified session.
`void`	`verifyNumberMessageProducers(int indexOfSession, int numberOfProducers)` Verifies the number of producers for the specified session.
`void`	`verifyNumberOfCreatedBytesMessages(int indexOfSession, int number)` Verifies the number of bytes messages created with `MockSession.createBytesMessage()`.
`void`	`verifyNumberOfCreatedMapMessages(int indexOfSession, int number)` Verifies the number of map messages created with `MockSession.createMapMessage()`.
`void`	`verifyNumberOfCreatedMessages(int indexOfSession, int number)` Verifies the number of messages created with `MockSession.createMessage()`.
`void`	`verifyNumberOfCreatedObjectMessages(int indexOfSession, int number)` Verifies the number of object messages created with `MockSession.createObjectMessage()`.
`void`	`verifyNumberOfCreatedQueueBytesMessages(int indexOfSession, int number)` Verifies the number of bytes messages created with `MockSession.createBytesMessage()`.
`void`	`verifyNumberOfCreatedQueueMapMessages(int indexOfSession, int number)` Verifies the number of map messages created with `MockSession.createMapMessage()`.
`void`	`verifyNumberOfCreatedQueueMessages(int indexOfSession, int number)` Verifies the number of messages created with `MockSession.createMessage()`.
`void`	`verifyNumberOfCreatedQueueObjectMessages(int indexOfSession, int number)` Verifies the number of object messages created with `MockSession.createObjectMessage()`.
`void`	`verifyNumberOfCreatedQueueStreamMessages(int indexOfSession, int number)` Verifies the number of stream messages created with `MockSession.createStreamMessage()`.
`void`	`verifyNumberOfCreatedQueueTextMessages(int indexOfSession, int number)` Verifies the number of text messages created with `MockSession.createTextMessage()`.
`void`	`verifyNumberOfCreatedStreamMessages(int indexOfSession, int number)` Verifies the number of stream messages created with `MockSession.createStreamMessage()`.
`void`	`verifyNumberOfCreatedTextMessages(int indexOfSession, int number)` Verifies the number of text messages created with `MockSession.createTextMessage()`.
`void`	`verifyNumberOfCreatedTopicBytesMessages(int indexOfSession, int number)` Verifies the number of bytes messages created with `MockSession.createBytesMessage()`.
`void`	`verifyNumberOfCreatedTopicMapMessages(int indexOfSession, int number)` Verifies the number of map messages created with `MockSession.createMapMessage()`.
`void`	`verifyNumberOfCreatedTopicMessages(int indexOfSession, int number)` Verifies the number of messages created with `MockSession.createMessage()`.
`void`	`verifyNumberOfCreatedTopicObjectMessages(int indexOfSession, int number)` Verifies the number of object messages created with `MockSession.createObjectMessage()`.
`void`	`verifyNumberOfCreatedTopicStreamMessages(int indexOfSession, int number)` Verifies the number of stream messages created with `MockSession.createStreamMessage()`.
`void`	`verifyNumberOfCreatedTopicTextMessages(int indexOfSession, int number)` Verifies the number of text messages created with `MockSession.createTextMessage()`.
`void`	`verifyNumberOfCurrentQueueMessages(int indexOfSession, int indexOfQueue, int numberOfMessages)` Verifies the number of messages in a temporary queue.
`void`	`verifyNumberOfCurrentQueueMessages(String nameOfQueue, int numberOfMessages)` Verifies the number of messages in a queue.
`void`	`verifyNumberOfCurrentTopicMessages(int indexOfSession, int indexOfTopic, int numberOfMessages)` Verifies the number of messages in a temporary topic.
`void`	`verifyNumberOfCurrentTopicMessages(String nameOfTopic, int numberOfMessages)` Verifies the number of messages in a topic.
`void`	`verifyNumberOfReceivedQueueMessages(int indexOfSession, int indexOfQueue, int numberOfMessages)` Verifies the number of messages received by a temporary queue.
`void`	`verifyNumberOfReceivedQueueMessages(String nameOfQueue, int numberOfMessages)` Verifies the number of messages received by a queue.
`void`	`verifyNumberOfReceivedTopicMessages(int indexOfSession, int indexOfTopic, int numberOfMessages)` Verifies the number of messages received by a temporary topic.
`void`	`verifyNumberOfReceivedTopicMessages(String nameOfTopic, int numberOfMessages)` Verifies the number of messages received by a topic.
`void`	`verifyNumberQueueBrowsers(int indexOfSession, int numberOfBrowsers)` Verifies the number of browsers for the specified session.
`void`	`verifyNumberQueueBrowsers(int indexOfSession, String queueName, int numberOfBrowsers)` Verifies the number of browsers for the specified session and the specified queue name.
`void`	`verifyNumberQueueReceivers(int indexOfSession, int numberOfReceivers)` Verifies the number of receivers for the specified session.
`void`	`verifyNumberQueueReceivers(int indexOfSession, String queueName, int numberOfReceivers)` Verifies the number of receivers for the specified session and the specified queue name.
`void`	`verifyNumberQueueSenders(int indexOfSession, int numberOfSenders)` Verifies the number of senders for the specified session.
`void`	`verifyNumberQueueSenders(int indexOfSession, String queueName, int numberOfSenders)` Verifies the number of senders for the specified session and the specified queue name.
`void`	`verifyNumberQueueSessions(int number)` Verifies the number of queue sessions.
`void`	`verifyNumberSessions(int number)` Verifies the number of sessions.
`void`	`verifyNumberTemporaryQueues(int indexOfSession, int numberQueues)` Verifies the number of temporary queues.
`void`	`verifyNumberTemporaryTopics(int indexOfSession, int numberTopics)` Verifies the number of temporary topics.
`void`	`verifyNumberTopicPublishers(int indexOfSession, int numberOfPublishers)` Verifies the number of publishers for the specified session.
`void`	`verifyNumberTopicPublishers(int indexOfSession, String topicName, int numberOfPublishers)` Verifies the number of publishers for the specified session and the specified topic name.
`void`	`verifyNumberTopicSessions(int number)` Verifies the number of topic sessions.
`void`	`verifyNumberTopicSubscribers(int indexOfSession, int numberOfSubscribers)` Verifies the number of subscribers for the specified session.
`void`	`verifyNumberTopicSubscribers(int indexOfSession, String topicName, int numberOfSubscribers)` Verifies the number of subscribers for the specified session and the specified topic name.
`void`	`verifyQueueBrowserClosed(int indexOfSession, String queueName, int indexOfBrowser)` Verifies that the specified browser is closed.
`void`	`verifyQueueConnectionClosed()` Verifies that the current `MockQueueConnection` is closed.
`void`	`verifyQueueConnectionStarted()` Verifies that the current `MockQueueConnection` is started.
`void`	`verifyQueueConnectionStopped()` Verifies that the current `MockQueueConnection` is stopped.
`void`	`verifyQueueReceiverClosed(int indexOfSession, String queueName, int indexOfReceiver)` Verifies that the specified receiver is closed.
`void`	`verifyQueueSenderClosed(int indexOfSession, String queueName, int indexOfSender)` Verifies that the specified sender is closed.
`void`	`verifyQueueSessionClosed(int indexOfSession)` Verifies that the queue session with the specified index is closed.
`void`	`verifyQueueSessionCommitted(int indexOfSession)` Verifies that the queue session with the specified index was committed.
`void`	`verifyQueueSessionNotCommitted(int indexOfSession)` Verifies that the queue session with the specified index was not committed.
`void`	`verifyQueueSessionNotRecovered(int indexOfSession)` Verifies that the queue session with the specified index was not recovered.
`void`	`verifyQueueSessionNotRolledBack(int indexOfSession)` Verifies that the queue session with the specified index was not rolled back.
`void`	`verifyQueueSessionNumberCommits(int indexOfSession, int numberOfCommits)` Verifies the number of commits of the queue session with the specified index.
`void`	`verifyQueueSessionNumberRollbacks(int indexOfSession, int numberOfRollbacks)` Verifies the number of rollbacks of the queue session with the specified index.
`void`	`verifyQueueSessionRecovered(int indexOfSession)` Verifies that the queue session with the specified index was recovered.
`void`	`verifyQueueSessionRolledBack(int indexOfSession)` Verifies that the queue session with the specified index was rolled back.
`void`	`verifyReceivedQueueMessageAcknowledged(int indexOfSession, int indexOfQueue, int indexOfMessage)` Verifies that message received by a temporary queue is acknowledged.
`void`	`verifyReceivedQueueMessageAcknowledged(String nameOfQueue, int indexOfMessage)` Verifies that a received message is acknowledged.
`void`	`verifyReceivedQueueMessageEquals(int indexOfSession, int indexOfQueue, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a message received by a temporary queue is equal to the specified message by calling the `equals()` method.
`void`	`verifyReceivedQueueMessageEquals(String nameOfQueue, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a received message is equal to the specified message by calling the `equals()` method.
`void`	`verifyReceivedQueueMessageNotAcknowledged(int indexOfSession, int indexOfQueue, int indexOfMessage)` Verifies that a received by a temporary queue is not acknowledged.
`void`	`verifyReceivedQueueMessageNotAcknowledged(String nameOfQueue, int indexOfMessage)` Verifies that a received message is not acknowledged.
`void`	`verifyReceivedTopicMessageAcknowledged(int indexOfSession, int indexOfTopic, int indexOfMessage)` Verifies that a message received by a temporary topic is acknowledged.
`void`	`verifyReceivedTopicMessageAcknowledged(String nameOfTopic, int indexOfMessage)` Verifies that a received message is acknowledged.
`void`	`verifyReceivedTopicMessageEquals(int indexOfSession, int indexOfTopic, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a message received by a temporary topic is equal to the specified message by calling the `equals()` method.
`void`	`verifyReceivedTopicMessageEquals(String nameOfTopic, int indexOfSourceMessage, MockMessage targetMessage)` Verifies that a received message is equal to the specified message by calling the `equals()` method.
`void`	`verifyReceivedTopicMessageNotAcknowledged(int indexOfSession, int indexOfTopic, int indexOfMessage)` Verifies that a message received by a temporary topic is not acknowledged.
`void`	`verifyReceivedTopicMessageNotAcknowledged(String nameOfTopic, int indexOfMessage)` Verifies that a received message is not acknowledged.
`void`	`verifySessionClosed(int indexOfSession)` Verifies that the session with the specified index is closed.
`void`	`verifySessionCommitted(int indexOfSession)` Verifies that the session with the specified index was committed.
`void`	`verifySessionNotCommitted(int indexOfSession)` Verifies that the session with the specified index was not committed.
`void`	`verifySessionNotRecovered(int indexOfSession)` Verifies that the session with the specified index was not recovered.
`void`	`verifySessionNotRolledBack(int indexOfSession)` Verifies that the session with the specified index was not rolled back.
`void`	`verifySessionNumberCommits(int indexOfSession, int numberOfCommits)` Verifies the number of commits of session with the specified index.
`void`	`verifySessionNumberRollbacks(int indexOfSession, int numberOfRollbacks)` Verifies the number of rollbacks of session with the specified index.
`void`	`verifySessionRecovered(int indexOfSession)` Verifies that the session with the specified index was recovered.
`void`	`verifySessionRolledBack(int indexOfSession)` Verifies that the session with the specified index was rolled back.
`void`	`verifyTemporaryQueueDeleted(int indexOfSession, int indexOfQueue)` Verifies that the temporary queue with the specified index was deleted.
`void`	`verifyTemporaryTopicDeleted(int indexOfSession, int indexOfTopic)` Verifies that the temporary topic with the specified index was closed.
`void`	`verifyTopicConnectionClosed()` Verifies that the current `MockTopicConnection` is closed.
`void`	`verifyTopicConnectionStarted()` Verifies that the current `MockTopicConnection` is started.
`void`	`verifyTopicConnectionStopped()` Verifies that the current `MockTopicConnection` is stopped.
`void`	`verifyTopicPublisherClosed(int indexOfSession, String topicName, int indexOfPublisher)` Verifies that the specified publisher is closed.
`void`	`verifyTopicSessionClosed(int indexOfSession)` Verifies that the topic session with the specified index is closed.
`void`	`verifyTopicSessionCommitted(int indexOfSession)` Verifies that the topic session with the specified index was committed.
`void`	`verifyTopicSessionNotCommitted(int indexOfSession)` Verifies that the topic session with the specified index was not committed.
`void`	`verifyTopicSessionNotRecovered(int indexOfSession)` Verifies that the topic session with the specified index was not recovered.
`void`	`verifyTopicSessionNotRolledBack(int indexOfSession)` Verifies that the topic session with the specified index was not rolled back.
`void`	`verifyTopicSessionNumberCommits(int indexOfSession, int numberOfCommits)` Verifies the number of commits of the topic session with the specified index.
`void`	`verifyTopicSessionNumberRollbacks(int indexOfSession, int numberOfRollbacks)` Verifies the number of rollbacks of the topic session with the specified index.
`void`	`verifyTopicSessionRecovered(int indexOfSession)` Verifies that the topic session with the specified index was recovered.
`void`	`verifyTopicSessionRolledBack(int indexOfSession)` Verifies that the topic session with the specified index was rolled back.
`void`	`verifyTopicSubscriberClosed(int indexOfSession, String topicName, int indexOfSubscriber)` Verifies that the specified subscriber is closed.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - JMSTestModule
```
public JMSTestModule(JMSMockObjectFactory mockFactory)
```
- Method Detail
  - setCurrentQueueConnectionIndex
```
public void setCurrentQueueConnectionIndex(int connectionIndex)
```
    Sets the index of the MockQueueConnection that should be used for the current test. Per default the latest created connection is used.
    
    Parameters:
    connectionIndex - the index of the connection
  - getCurrentQueueConnection
```
public MockQueueConnection getCurrentQueueConnection()
```
    Returns the current MockQueueConnection based on its index or null if no queue connection was created. The connection has to be created using the MockQueueConnectionFactory.
    
    Returns:
    the queue connection
  - setCurrentTopicConnectionIndex
```
public void setCurrentTopicConnectionIndex(int connectionIndex)
```
    Sets the index of the MockTopicConnection that should be used for the current test. Per default the latest created connection is used.
    
    Parameters:
    connectionIndex - the index of the connection
  - getCurrentTopicConnection
```
public MockTopicConnection getCurrentTopicConnection()
```
    Returns the current MockTopicConnection based on its index or null if no topic connection was created. The connection has to be created using the MockTopicConnectionFactory.
    
    Returns:
    the topic connection
  - setCurrentConnectionIndex
```
public void setCurrentConnectionIndex(int connectionIndex)
```
    Sets the index of the MockConnection that should be used for the current test. Per default the latest created connection is used.
    
    Parameters:
    connectionIndex - the index of the connection
  - getCurrentConnection
```
public MockConnection getCurrentConnection()
```
    Returns the current MockConnection based on its index or null if no connection was created. The connection has to be created using the MockConnectionFactory.
    
    Returns:
    the topic connection
  - registerTestMessageListenerForQueue
```
public void registerTestMessageListenerForQueue(String queueName,
                                       javax.jms.MessageListener listener)
```
    Creates a new connection and uses it for creating a new session and receiver. Registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing senders. It can be used to register message driven beans. Note that the created connection is the latest created connection and automatically becomes the default connection for the test module. The created session is transacted. This method uses the MockQueueConnectionFactory for creating the connection and the session. If you want to use the MockConnectionFactory you have to create the connection on your own and call registerTestMessageListenerForQueue(MockConnection, String, MessageListener).
    
    Parameters:
    queueName - the name of the queue used for message receiving
    listener - the listener that should be registered
  - registerTestMessageListenerForQueue
```
public void registerTestMessageListenerForQueue(MockConnection connection,
                                       String queueName,
                                       javax.jms.MessageListener listener)
```
    Creates a new session and receiver using the specified connection and registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing senders. It can be used to register message driven beans. The created session is transacted.
    
    Parameters:
    connection - the connection used for creating the session
    queueName - the name of the queue used for message receiving
    listener - the listener that should be registered
  - registerTestMessageListenerForQueue
```
public void registerTestMessageListenerForQueue(MockConnection connection,
                                       String queueName,
                                       boolean transacted,
                                       int acknowledgeMode,
                                       javax.jms.MessageListener listener)
```
    Creates a new session and receiver using the specified connection and registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing senders. It can be used to register message driven beans.
    
    Parameters:
    connection - the connection used for creating the session
    queueName - the name of the queue used for message receiving
    transacted - should the created session be transacted
    acknowledgeMode - the acknowledge mode of the created session
    listener - the listener that should be registered
  - registerTestMessageListenerForQueue
```
public void registerTestMessageListenerForQueue(MockConnection connection,
                                       String queueName,
                                       boolean transacted,
                                       int acknowledgeMode,
                                       String messageSelector,
                                       javax.jms.MessageListener listener)
```
    Creates a new session and receiver using the specified connection and registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing senders. It can be used to register message driven beans.
    
    Parameters:
    connection - the connection used for creating the session
    queueName - the name of the queue used for message receiving
    transacted - should the created session be transacted
    acknowledgeMode - the acknowledge mode of the created session
    messageSelector - the message selector
    listener - the listener that should be registered
  - registerTestMessageListenerForTopic
```
public void registerTestMessageListenerForTopic(String topicName,
                                       javax.jms.MessageListener listener)
```
    Creates a new connection and uses it for creating a new session and subscriber. Registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing publishers. It can be used to resgister message driven beans. Note that the created connection is the latest created connection and automatically becomes the default connection for the test module. The created session is transacted. This method uses the MockTopicConnectionFactory for creating the connection and the session. If you want to use the MockConnectionFactory you have to create the connection on your own and call registerTestMessageListenerForTopic(MockConnection, String, MessageListener).
    
    Parameters:
    topicName - the name of the topic used for message receiving
    listener - the listener that should be registered
  - registerTestMessageListenerForTopic
```
public void registerTestMessageListenerForTopic(MockConnection connection,
                                       String topicName,
                                       javax.jms.MessageListener listener)
```
    Creates a new session and subscriber using the specified connection and registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing publishers. It can be used to resgister message driven beans. The created session is transacted.
    
    Parameters:
    connection - the connection used for creating the session
    topicName - the name of the topic used for message receiving
    listener - the listener that should be registered
  - registerTestMessageListenerForTopic
```
public void registerTestMessageListenerForTopic(MockConnection connection,
                                       String topicName,
                                       boolean transacted,
                                       int acknowledgeMode,
                                       javax.jms.MessageListener listener)
```
    Creates a new session and subscriber using the specified connection and registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing publishers. It can be used to resgister message driven beans.
    
    Parameters:
    connection - the connection used for creating the session
    topicName - the name of the topic used for message receiving
    transacted - should the created session be transacted
    acknowledgeMode - the acknowledge mode of the created session
    listener - the listener that should be registered
  - registerTestMessageListenerForTopic
```
public void registerTestMessageListenerForTopic(MockConnection connection,
                                       String topicName,
                                       boolean transacted,
                                       int acknowledgeMode,
                                       String messageSelector,
                                       javax.jms.MessageListener listener)
```
    Creates a new session and subscriber using the specified connection and registers the specified listener. Starts the connection for message receiving. This method is useful for creating test listeners when testing publishers. It can be used to resgister message driven beans.
    
    Parameters:
    connection - the connection used for creating the session
    topicName - the name of the topic used for message receiving
    transacted - should the created session be transacted
    acknowledgeMode - the acknowledge mode of the created session
    messageSelector - the message selector
    listener - the listener that should be registered
  - getDestinationManager
```
public DestinationManager getDestinationManager()
```
    Returns the DestinationManager.
    
    Returns:
    the DestinationManager
  - getConfigurationManager
```
public ConfigurationManager getConfigurationManager()
```
    Returns the ConfigurationManager.
    
    Returns:
    the ConfigurationManager
  - getQueueMessageManager
```
public MessageManager getQueueMessageManager(int indexOfSession)
```
    Returns the MessageManager for the specified session or null if the session does not exist. The returned MessageManager is used to keep track of messages sent to queues. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MessageManager
  - getTopicMessageManager
```
public MessageManager getTopicMessageManager(int indexOfSession)
```
    Returns the MessageManager for the specified session or null if the session does not exist. The returned MessageManager is used to keep track of messages sent to topics. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MessageManager
  - getMessageManager
```
public MessageManager getMessageManager(int indexOfSession)
```
    Returns the MessageManager for the specified session or null if the session does not exist. The returned MessageManager is used to keep track of messages sent to topics. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MessageManager
  - getQueueTransmissionManager
```
public QueueTransmissionManager getQueueTransmissionManager(int indexOfSession)
```
    Returns the QueueTransmissionManager for the specified session or null if the session does not exist. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the QueueTransmissionManager
  - getTopicTransmissionManager
```
public TopicTransmissionManager getTopicTransmissionManager(int indexOfSession)
```
    Returns the TopicTransmissionManager for the specified session or null if the session does not exist. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the TopicTransmissionManager
  - getTransmissionManager
```
public TransmissionManagerWrapper getTransmissionManager(int indexOfSession)
```
    Deprecated. use getTransmissionManagerWrapper(int)
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the TransmissionManagerWrapper
  - getTransmissionManagerWrapper
```
public TransmissionManagerWrapper getTransmissionManagerWrapper(int indexOfSession)
```
    Returns the TransmissionManagerWrapper for the specified session or null if the session does not exist. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the TransmissionManagerWrapper
  - getQueueTransmissionManagerWrapper
```
public TransmissionManagerWrapper getQueueTransmissionManagerWrapper(int indexOfSession)
```
    Returns the TransmissionManagerWrapper for the specified session or null if the session does not exist. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the TransmissionManagerWrapper
  - getTopicTransmissionManagerWrapper
```
public TransmissionManagerWrapper getTopicTransmissionManagerWrapper(int indexOfSession)
```
    Returns the TransmissionManagerWrapper for the specified session or null if the session does not exist. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the TransmissionManagerWrapper
  - getQueueSessionList
```
public List getQueueSessionList()
```
    Returns the list of MockQueueSession objects. The sessions have been created using the current MockQueueConnection.
    
    Returns:
    the MockQueueSession list
  - getTopicSessionList
```
public List getTopicSessionList()
```
    Returns the list of MockTopicSession objects. The sessions have been created using the current MockTopicConnection.
    
    Returns:
    the MockTopicSession list
  - getSessionList
```
public List getSessionList()
```
    Returns the list of MockSession objects. The sessions have been created using the current MockConnection.
    
    Returns:
    the MockSession list
  - getQueueSession
```
public MockQueueSession getQueueSession(int indexOfSession)
```
    Returns the MockQueueSession for the specified index or null if the session does not exist. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MockQueueSession
  - getTopicSession
```
public MockTopicSession getTopicSession(int indexOfSession)
```
    Returns the MockTopicSession for the specified index or null if the session does not exist. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MockTopicSession
  - getSession
```
public MockSession getSession(int indexOfSession)
```
    Returns the MockSession for the specified index or null if the session does not exist. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MockSession
  - getQueue
```
public MockQueue getQueue(String name)
```
    Returns the MockQueue with the specified name or null if no such queue exists.
    
    Parameters:
    name - the name of the queue
    
    Returns:
    the MockQueue
  - getTopic
```
public MockTopic getTopic(String name)
```
    Returns the MockTopic with the specified name or null if no such topic exists.
    
    Parameters:
    name - the name of the topic
    
    Returns:
    the MockTopic
  - getTemporaryQueueList
```
public List getTemporaryQueueList(int indexOfSession)
```
    Returns the list of MockTemporaryQueue objects for the specified session. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MockTemporaryQueue list
  - getTemporaryTopicList
```
public List getTemporaryTopicList(int indexOfSession)
```
    Returns the list of MockTemporaryTopic objects for the specified session. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Returns:
    the MockTemporaryTopic list
  - getTemporaryQueue
```
public MockTemporaryQueue getTemporaryQueue(int indexOfSession,
                                   int indexOfQueue)
```
    Returns the MockTemporaryQueue with the specified index for the specified session. Returns null if no such temporary queue exists. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    
    Returns:
    the MockTemporaryQueue
  - getTemporaryTopic
```
public MockTemporaryTopic getTemporaryTopic(int indexOfSession,
                                   int indexOfTopic)
```
    Returns the MockTemporaryTopic with the specified index for the specified session. Returns null if no such temporary queue exists. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary queue
    
    Returns:
    the MockTemporaryTopic
  - getCurrentMessageListFromQueue
```
public List getCurrentMessageListFromQueue(String name)
```
    Returns the list of messages that are currently present in the queue or null if no such queue exists.
    
    Parameters:
    name - the name of the queue
    
    Returns:
    the list of messages
  - getCurrentMessageListFromTemporaryQueue
```
public List getCurrentMessageListFromTemporaryQueue(int indexOfSession,
                                           int indexOfQueue)
```
    Returns the list of messages that are currently present in the temporary queue or null if no such queue exists. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    
    Returns:
    the list of messages
  - getReceivedMessageListFromQueue
```
public List getReceivedMessageListFromQueue(String name)
```
    Returns the list of messages that were received by the queue or null if no such queue exists.
    
    Parameters:
    name - the name of the queue
    
    Returns:
    the list of messages
  - getReceivedMessageListFromTemporaryQueue
```
public List getReceivedMessageListFromTemporaryQueue(int indexOfSession,
                                            int indexOfQueue)
```
    Returns the list of messages that were received by the temporary queue or null if no such queue exists. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    
    Returns:
    the list of messages
  - getCurrentMessageListFromTopic
```
public List getCurrentMessageListFromTopic(String name)
```
    Returns the list of messages that are currently present in the topic or null if no such topic exists.
    
    Parameters:
    name - the name of the queue
    
    Returns:
    the list of messages
  - getCurrentMessageListFromTemporaryTopic
```
public List getCurrentMessageListFromTemporaryTopic(int indexOfSession,
                                           int indexOfTopic)
```
    Returns the list of messages that are currently present in the temporary topic or null if no such topic exists. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    
    Returns:
    the list of messages
  - getReceivedMessageListFromTopic
```
public List getReceivedMessageListFromTopic(String name)
```
    Returns the list of messages that were received by the topic or null if no such topic exists.
    
    Parameters:
    name - the name of the topic
    
    Returns:
    the list of messages
  - getReceivedMessageListFromTemporaryTopic
```
public List getReceivedMessageListFromTemporaryTopic(int indexOfSession,
                                            int indexOfTopic)
```
    Returns the list of messages that were received by the temporary topic or null if no such topic exists. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    
    Returns:
    the list of messages
  - verifyQueueConnectionClosed
```
public void verifyQueueConnectionClosed()
```
    Verifies that the current MockQueueConnection is closed. The connection has to be created using the current MockQueueConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueConnectionStarted
```
public void verifyQueueConnectionStarted()
```
    Verifies that the current MockQueueConnection is started. The connection has to be created using the current MockQueueConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueConnectionStopped
```
public void verifyQueueConnectionStopped()
```
    Verifies that the current MockQueueConnection is stopped. The connection has to be created using the current MockQueueConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicConnectionClosed
```
public void verifyTopicConnectionClosed()
```
    Verifies that the current MockTopicConnection is closed. The connection has to be created using the current MockTopicConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicConnectionStarted
```
public void verifyTopicConnectionStarted()
```
    Verifies that the current MockTopicConnection is started. The connection has to be created using the current MockTopicConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicConnectionStopped
```
public void verifyTopicConnectionStopped()
```
    Verifies that the current MockTopicConnection is stopped. The connection has to be created using the current MockTopicConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyConnectionClosed
```
public void verifyConnectionClosed()
```
    Verifies that the current MockConnection is closed. The connection has to be created using the current MockConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyConnectionStarted
```
public void verifyConnectionStarted()
```
    Verifies that the current MockConnection is started. The connection has to be created using the current MockConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyConnectionStopped
```
public void verifyConnectionStopped()
```
    Verifies that the current MockConnection is stopped. The connection has to be created using the current MockConnectionFactory.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionClosed
```
public void verifyQueueSessionClosed(int indexOfSession)
```
    Verifies that the queue session with the specified index is closed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionCommitted
```
public void verifyQueueSessionCommitted(int indexOfSession)
```
    Verifies that the queue session with the specified index was committed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionNotCommitted
```
public void verifyQueueSessionNotCommitted(int indexOfSession)
```
    Verifies that the queue session with the specified index was not committed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionNumberCommits
```
public void verifyQueueSessionNumberCommits(int indexOfSession,
                                   int numberOfCommits)
```
    Verifies the number of commits of the queue session with the specified index. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfCommits - the expected number of commits
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionRolledBack
```
public void verifyQueueSessionRolledBack(int indexOfSession)
```
    Verifies that the queue session with the specified index was rolled back. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionNotRolledBack
```
public void verifyQueueSessionNotRolledBack(int indexOfSession)
```
    Verifies that the queue session with the specified index was not rolled back. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionNumberRollbacks
```
public void verifyQueueSessionNumberRollbacks(int indexOfSession,
                                     int numberOfRollbacks)
```
    Verifies the number of rollbacks of the queue session with the specified index. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfRollbacks - the expected number of rollbacks
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionRecovered
```
public void verifyQueueSessionRecovered(int indexOfSession)
```
    Verifies that the queue session with the specified index was recovered. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSessionNotRecovered
```
public void verifyQueueSessionNotRecovered(int indexOfSession)
```
    Verifies that the queue session with the specified index was not recovered. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionClosed
```
public void verifyTopicSessionClosed(int indexOfSession)
```
    Verifies that the topic session with the specified index is closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionCommitted
```
public void verifyTopicSessionCommitted(int indexOfSession)
```
    Verifies that the topic session with the specified index was committed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionNotCommitted
```
public void verifyTopicSessionNotCommitted(int indexOfSession)
```
    Verifies that the topic session with the specified index was not committed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionNumberCommits
```
public void verifyTopicSessionNumberCommits(int indexOfSession,
                                   int numberOfCommits)
```
    Verifies the number of commits of the topic session with the specified index. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfCommits - the expected number of commits
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionRolledBack
```
public void verifyTopicSessionRolledBack(int indexOfSession)
```
    Verifies that the topic session with the specified index was rolled back. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionNotRolledBack
```
public void verifyTopicSessionNotRolledBack(int indexOfSession)
```
    Verifies that the topic session with the specified index was not rolled back. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionNumberRollbacks
```
public void verifyTopicSessionNumberRollbacks(int indexOfSession,
                                     int numberOfRollbacks)
```
    Verifies the number of rollbacks of the topic session with the specified index. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfRollbacks - the expected number of rollbacks
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionRecovered
```
public void verifyTopicSessionRecovered(int indexOfSession)
```
    Verifies that the topic session with the specified index was recovered. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSessionNotRecovered
```
public void verifyTopicSessionNotRecovered(int indexOfSession)
```
    Verifies that the topic session with the specified index was not recovered. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionClosed
```
public void verifySessionClosed(int indexOfSession)
```
    Verifies that the session with the specified index is closed. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionCommitted
```
public void verifySessionCommitted(int indexOfSession)
```
    Verifies that the session with the specified index was committed. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionNotCommitted
```
public void verifySessionNotCommitted(int indexOfSession)
```
    Verifies that the session with the specified index was not committed. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionNumberCommits
```
public void verifySessionNumberCommits(int indexOfSession,
                              int numberOfCommits)
```
    Verifies the number of commits of session with the specified index. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfCommits - the expected number of commits
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionRolledBack
```
public void verifySessionRolledBack(int indexOfSession)
```
    Verifies that the session with the specified index was rolled back. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionNotRolledBack
```
public void verifySessionNotRolledBack(int indexOfSession)
```
    Verifies that the session with the specified index was not rolled back. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionNumberRollbacks
```
public void verifySessionNumberRollbacks(int indexOfSession,
                                int numberOfRollbacks)
```
    Verifies the number of rollbacks of session with the specified index. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfRollbacks - the expected number of rollbacks
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionRecovered
```
public void verifySessionRecovered(int indexOfSession)
```
    Verifies that the session with the specified index was recovered. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifySessionNotRecovered
```
public void verifySessionNotRecovered(int indexOfSession)
```
    Verifies that the session with the specified index was not recovered. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllQueueSessionsClosed
```
public void verifyAllQueueSessionsClosed()
```
    Verifies that all queue sessions are closed. The sessions have to be created using the current MockQueueConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllQueueSessionsRecovered
```
public void verifyAllQueueSessionsRecovered()
```
    Verifies that all queue sessions are recovered. The sessions have to be created using the current MockQueueConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllQueueSessionsCommitted
```
public void verifyAllQueueSessionsCommitted()
```
    Verifies that all queue sessions were commited. The sessions have to be created using the current MockQueueConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllQueueSessionsRolledBack
```
public void verifyAllQueueSessionsRolledBack()
```
    Verifies that all queue sessions were rolled back. The sessions have to be created using the current MockQueueConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTopicSessionsClosed
```
public void verifyAllTopicSessionsClosed()
```
    Verifies that all topic sessions are closed. The sessions have to be created using the current MockTopicConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTopicSessionsRecovered
```
public void verifyAllTopicSessionsRecovered()
```
    Verifies that all topic sessions are recovered. The sessions have to be created using the current MockTopicConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTopicSessionsCommitted
```
public void verifyAllTopicSessionsCommitted()
```
    Verifies that all topic sessions were commited. The sessions have to be created using the current MockTopicConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTopicSessionsRolledBack
```
public void verifyAllTopicSessionsRolledBack()
```
    Verifies that all topic sessions were rolled back. The sessions have to be created using the current MockTopicConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllSessionsClosed
```
public void verifyAllSessionsClosed()
```
    Verifies that all sessions are closed. The sessions have to be created using the current MockConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllSessionsRecovered
```
public void verifyAllSessionsRecovered()
```
    Verifies that all sessions are recovered. The sessions have to be created using the current MockConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllSessionsCommitted
```
public void verifyAllSessionsCommitted()
```
    Verifies that all sessions were commited. The sessions have to be created using the current MockConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllSessionsRolledBack
```
public void verifyAllSessionsRolledBack()
```
    Verifies that all topic sessions were rolled back. The sessions have to be created using the current MockConnection.
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberMessageProducers
```
public void verifyNumberMessageProducers(int indexOfSession,
                                int numberOfProducers)
```
    Verifies the number of producers for the specified session. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfProducers - the expected number of producers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllMessageProducersClosed
```
public void verifyAllMessageProducersClosed(int indexOfSession)
```
    Verifies that all producers for the specified session are closed. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberQueueSenders
```
public void verifyNumberQueueSenders(int indexOfSession,
                            int numberOfSenders)
```
    Verifies the number of senders for the specified session. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfSenders - the expected number of senders
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberQueueSenders
```
public void verifyNumberQueueSenders(int indexOfSession,
                            String queueName,
                            int numberOfSenders)
```
    Verifies the number of senders for the specified session and the specified queue name. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    queueName - the name of the queue
    numberOfSenders - the expected number of senders
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueSenderClosed
```
public void verifyQueueSenderClosed(int indexOfSession,
                           String queueName,
                           int indexOfSender)
```
    Verifies that the specified sender is closed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    queueName - the name of the queue
    indexOfSender - the index of the sender
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllQueueSendersClosed
```
public void verifyAllQueueSendersClosed(int indexOfSession)
```
    Verifies that all senders for the specified session are closed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberTopicPublishers
```
public void verifyNumberTopicPublishers(int indexOfSession,
                               int numberOfPublishers)
```
    Verifies the number of publishers for the specified session. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfPublishers - the expected number of publishers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberTopicPublishers
```
public void verifyNumberTopicPublishers(int indexOfSession,
                               String topicName,
                               int numberOfPublishers)
```
    Verifies the number of publishers for the specified session and the specified topic name. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    topicName - the name of the topic
    numberOfPublishers - the expected number of publishers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicPublisherClosed
```
public void verifyTopicPublisherClosed(int indexOfSession,
                              String topicName,
                              int indexOfPublisher)
```
    Verifies that the specified publisher is closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    topicName - the name of the topic
    indexOfPublisher - the index of the publisher
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTopicPublishersClosed
```
public void verifyAllTopicPublishersClosed(int indexOfSession)
```
    Verifies that all publishers for the specified session are closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberMessageConsumers
```
public void verifyNumberMessageConsumers(int indexOfSession,
                                int numberOfConsumers)
```
    Verifies the number of consumers for the specified session. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfConsumers - the expected number of consumers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllMessageConsumersClosed
```
public void verifyAllMessageConsumersClosed(int indexOfSession)
```
    Verifies that all consumers for the specified session are closed. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberQueueReceivers
```
public void verifyNumberQueueReceivers(int indexOfSession,
                              int numberOfReceivers)
```
    Verifies the number of receivers for the specified session. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfReceivers - the expected number of receivers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberQueueReceivers
```
public void verifyNumberQueueReceivers(int indexOfSession,
                              String queueName,
                              int numberOfReceivers)
```
    Verifies the number of receivers for the specified session and the specified queue name. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    queueName - the name of the queue
    numberOfReceivers - the expected number of receivers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueReceiverClosed
```
public void verifyQueueReceiverClosed(int indexOfSession,
                             String queueName,
                             int indexOfReceiver)
```
    Verifies that the specified receiver is closed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    queueName - the name of the queue
    indexOfReceiver - the index of the receiver
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllQueueReceiversClosed
```
public void verifyAllQueueReceiversClosed(int indexOfSession)
```
    Verifies that all receivers for the specified session are closed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberTopicSubscribers
```
public void verifyNumberTopicSubscribers(int indexOfSession,
                                int numberOfSubscribers)
```
    Verifies the number of subscribers for the specified session. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfSubscribers - the expected number of subscribers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberTopicSubscribers
```
public void verifyNumberTopicSubscribers(int indexOfSession,
                                String topicName,
                                int numberOfSubscribers)
```
    Verifies the number of subscribers for the specified session and the specified topic name. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    topicName - the name of the topic
    numberOfSubscribers - the expected number of subscribers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTopicSubscriberClosed
```
public void verifyTopicSubscriberClosed(int indexOfSession,
                               String topicName,
                               int indexOfSubscriber)
```
    Verifies that the specified subscriber is closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    topicName - the name of the topic
    indexOfSubscriber - the index of the receiver
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTopicSubscribersClosed
```
public void verifyAllTopicSubscribersClosed(int indexOfSession)
```
    Verifies that all subscribers for the specified session are closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberQueueBrowsers
```
public void verifyNumberQueueBrowsers(int indexOfSession,
                             int numberOfBrowsers)
```
    Verifies the number of browsers for the specified session. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfBrowsers - the expected number of browsers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberQueueBrowsers
```
public void verifyNumberQueueBrowsers(int indexOfSession,
                             String queueName,
                             int numberOfBrowsers)
```
    Verifies the number of browsers for the specified session and the specified queue name. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    queueName - the name of the queue
    numberOfBrowsers - the expected number of browsers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyQueueBrowserClosed
```
public void verifyQueueBrowserClosed(int indexOfSession,
                            String queueName,
                            int indexOfBrowser)
```
    Verifies that the specified browser is closed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    queueName - the name of the queue
    indexOfBrowser - the index of the browser
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllQueueBrowsersClosed
```
public void verifyAllQueueBrowsersClosed(int indexOfSession)
```
    Verifies that all browsers for the specified session are closed. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyDurableTopicSubscriberPresent
```
public void verifyDurableTopicSubscriberPresent(int indexOfSession,
                                       String name)
```
    Verifies that a durable subscriber exists. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    name - the name of the subscription
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberDurableTopicSubscribers
```
public void verifyNumberDurableTopicSubscribers(int indexOfSession,
                                       int numberOfSubscribers)
```
    Verifies the number of durable subscribers for the specified session. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberOfSubscribers - the expected number of durable subscribers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberDurableTopicSubscribers
```
public void verifyNumberDurableTopicSubscribers(int indexOfSession,
                                       String topicName,
                                       int numberOfSubscribers)
```
    Verifies the number of durable subscribers for the specified session and the specified topic name. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    topicName - the name of the topic
    numberOfSubscribers - the expected number of durable subscribers
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyDurableTopicSubscriberClosed
```
public void verifyDurableTopicSubscriberClosed(int indexOfSession,
                                      String name)
```
    Verifies that the specified durable subscriber is closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    name - the name of the subscription
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllDurableTopicSubscribersClosed
```
public void verifyAllDurableTopicSubscribersClosed(int indexOfSession)
```
    Verifies that all durable subscribers for the specified session are closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberQueueSessions
```
public void verifyNumberQueueSessions(int number)
```
    Verifies the number of queue sessions. The sessions have to be created using the current MockQueueConnection.
    
    Parameters:
    number - the expected number of queue sessions
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberTopicSessions
```
public void verifyNumberTopicSessions(int number)
```
    Verifies the number of topic sessions. The sessions have to be created using the current MockTopicConnection.
    
    Parameters:
    number - the expected number of topic sessions
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberSessions
```
public void verifyNumberSessions(int number)
```
    Verifies the number of sessions. The sessions have to be created using the current MockConnection.
    
    Parameters:
    number - the expected number of sessions
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberTemporaryQueues
```
public void verifyNumberTemporaryQueues(int indexOfSession,
                               int numberQueues)
```
    Verifies the number of temporary queues. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberQueues - the expected number of temporary queues
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberTemporaryTopics
```
public void verifyNumberTemporaryTopics(int indexOfSession,
                               int numberTopics)
```
    Verifies the number of temporary topics. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    numberTopics - the expected number of temporary topics
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTemporaryQueueDeleted
```
public void verifyTemporaryQueueDeleted(int indexOfSession,
                               int indexOfQueue)
```
    Verifies that the temporary queue with the specified index was deleted. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the queue
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTemporaryQueuesDeleted
```
public void verifyAllTemporaryQueuesDeleted(int indexOfSession)
```
    Verifies that all temporary queues were deleted. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyTemporaryTopicDeleted
```
public void verifyTemporaryTopicDeleted(int indexOfSession,
                               int indexOfTopic)
```
    Verifies that the temporary topic with the specified index was closed. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the topic
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllTemporaryTopicsDeleted
```
public void verifyAllTemporaryTopicsDeleted(int indexOfSession)
```
    Verifies that all temporary topics were deleted. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyMessageEquals
```
public void verifyMessageEquals(MockMessage message1,
                       MockMessage message2)
```
    Verifies that the specified messages are equal by calling the equals() method. All mock messages provide a suitable implementation of equals().
    
    Parameters:
    message1 - the first message
    message2 - the second message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCurrentQueueMessageEquals
```
public void verifyCurrentQueueMessageEquals(String nameOfQueue,
                                   int indexOfSourceMessage,
                                   MockMessage targetMessage)
```
    Verifies that a message in the specified queue is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals().
    
    Parameters:
    nameOfQueue - the name of the queue
    indexOfSourceMessage - the index of the message in the queue
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedQueueMessageEquals
```
public void verifyReceivedQueueMessageEquals(String nameOfQueue,
                                    int indexOfSourceMessage,
                                    MockMessage targetMessage)
```
    Verifies that a received message is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals().
    
    Parameters:
    nameOfQueue - the name of the queue
    indexOfSourceMessage - the index of the received message
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCurrentQueueMessageEquals
```
public void verifyCurrentQueueMessageEquals(int indexOfSession,
                                   int indexOfQueue,
                                   int indexOfSourceMessage,
                                   MockMessage targetMessage)
```
    Verifies that a message in the specified temporary queue is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    indexOfSourceMessage - the index of the message in the queue
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedQueueMessageEquals
```
public void verifyReceivedQueueMessageEquals(int indexOfSession,
                                    int indexOfQueue,
                                    int indexOfSourceMessage,
                                    MockMessage targetMessage)
```
    Verifies that a message received by a temporary queue is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    indexOfSourceMessage - the index of the received message
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCurrentQueueMessages
```
public void verifyNumberOfCurrentQueueMessages(String nameOfQueue,
                                      int numberOfMessages)
```
    Verifies the number of messages in a queue.
    
    Parameters:
    nameOfQueue - the name of the queue
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfReceivedQueueMessages
```
public void verifyNumberOfReceivedQueueMessages(String nameOfQueue,
                                       int numberOfMessages)
```
    Verifies the number of messages received by a queue.
    
    Parameters:
    nameOfQueue - the name of the queue
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCurrentQueueMessages
```
public void verifyNumberOfCurrentQueueMessages(int indexOfSession,
                                      int indexOfQueue,
                                      int numberOfMessages)
```
    Verifies the number of messages in a temporary queue. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfReceivedQueueMessages
```
public void verifyNumberOfReceivedQueueMessages(int indexOfSession,
                                       int indexOfQueue,
                                       int numberOfMessages)
```
    Verifies the number of messages received by a temporary queue. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllReceivedQueueMessagesAcknowledged
```
public void verifyAllReceivedQueueMessagesAcknowledged(String nameOfQueue)
```
    Verifies that all received messages of the specified queue are acknowledged.
    
    Parameters:
    nameOfQueue - the name of the queue
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllReceivedQueueMessagesAcknowledged
```
public void verifyAllReceivedQueueMessagesAcknowledged(int indexOfSession,
                                              int indexOfQueue)
```
    Verifies that all received messages of the specified temporary queue are acknowledged. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedQueueMessageAcknowledged
```
public void verifyReceivedQueueMessageAcknowledged(String nameOfQueue,
                                          int indexOfMessage)
```
    Verifies that a received message is acknowledged.
    
    Parameters:
    nameOfQueue - the name of the queue
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedQueueMessageNotAcknowledged
```
public void verifyReceivedQueueMessageNotAcknowledged(String nameOfQueue,
                                             int indexOfMessage)
```
    Verifies that a received message is not acknowledged.
    
    Parameters:
    nameOfQueue - the name of the queue
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedQueueMessageAcknowledged
```
public void verifyReceivedQueueMessageAcknowledged(int indexOfSession,
                                          int indexOfQueue,
                                          int indexOfMessage)
```
    Verifies that message received by a temporary queue is acknowledged. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedQueueMessageNotAcknowledged
```
public void verifyReceivedQueueMessageNotAcknowledged(int indexOfSession,
                                             int indexOfQueue,
                                             int indexOfMessage)
```
    Verifies that a received by a temporary queue is not acknowledged. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfQueue - the index of the temporary queue
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedQueueMessages
```
public void verifyNumberOfCreatedQueueMessages(int indexOfSession,
                                      int number)
```
    Verifies the number of messages created with MockSession.createMessage(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedQueueBytesMessages
```
public void verifyNumberOfCreatedQueueBytesMessages(int indexOfSession,
                                           int number)
```
    Verifies the number of bytes messages created with MockSession.createBytesMessage(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of bytes messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedQueueMapMessages
```
public void verifyNumberOfCreatedQueueMapMessages(int indexOfSession,
                                         int number)
```
    Verifies the number of map messages created with MockSession.createMapMessage(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of map messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedQueueTextMessages
```
public void verifyNumberOfCreatedQueueTextMessages(int indexOfSession,
                                          int number)
```
    Verifies the number of text messages created with MockSession.createTextMessage(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of text messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedQueueStreamMessages
```
public void verifyNumberOfCreatedQueueStreamMessages(int indexOfSession,
                                            int number)
```
    Verifies the number of stream messages created with MockSession.createStreamMessage(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of stream messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedQueueObjectMessages
```
public void verifyNumberOfCreatedQueueObjectMessages(int indexOfSession,
                                            int number)
```
    Verifies the number of object messages created with MockSession.createObjectMessage(). The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of object messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueMessageAcknowledged
```
public void verifyCreatedQueueMessageAcknowledged(int indexOfSession,
                                         int indexOfMessage)
```
    Verifies that a message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueMessageNotAcknowledged
```
public void verifyCreatedQueueMessageNotAcknowledged(int indexOfSession,
                                            int indexOfMessage)
```
    Verifies that a message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueBytesMessageAcknowledged
```
public void verifyCreatedQueueBytesMessageAcknowledged(int indexOfSession,
                                              int indexOfMessage)
```
    Verifies that a bytes message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueBytesMessageNotAcknowledged
```
public void verifyCreatedQueueBytesMessageNotAcknowledged(int indexOfSession,
                                                 int indexOfMessage)
```
    Verifies that a bytes message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueMapMessageAcknowledged
```
public void verifyCreatedQueueMapMessageAcknowledged(int indexOfSession,
                                            int indexOfMessage)
```
    Verifies that a map message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueMapMessageNotAcknowledged
```
public void verifyCreatedQueueMapMessageNotAcknowledged(int indexOfSession,
                                               int indexOfMessage)
```
    Verifies that a map message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueTextMessageAcknowledged
```
public void verifyCreatedQueueTextMessageAcknowledged(int indexOfSession,
                                             int indexOfMessage)
```
    Verifies that a text message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueTextMessageNotAcknowledged
```
public void verifyCreatedQueueTextMessageNotAcknowledged(int indexOfSession,
                                                int indexOfMessage)
```
    Verifies that a text message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueStreamMessageAcknowledged
```
public void verifyCreatedQueueStreamMessageAcknowledged(int indexOfSession,
                                               int indexOfMessage)
```
    Verifies that a stream message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueStreamMessageNotAcknowledged
```
public void verifyCreatedQueueStreamMessageNotAcknowledged(int indexOfSession,
                                                  int indexOfMessage)
```
    Verifies that a stream message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueObjectMessageAcknowledged
```
public void verifyCreatedQueueObjectMessageAcknowledged(int indexOfSession,
                                               int indexOfMessage)
```
    Verifies that a object message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedQueueObjectMessageNotAcknowledged
```
public void verifyCreatedQueueObjectMessageNotAcknowledged(int indexOfSession,
                                                  int indexOfMessage)
```
    Verifies that a object message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockQueueConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCurrentTopicMessageEquals
```
public void verifyCurrentTopicMessageEquals(String nameOfTopic,
                                   int indexOfSourceMessage,
                                   MockMessage targetMessage)
```
    Verifies that a message in the specified topic is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals().
    
    Parameters:
    nameOfTopic - the name of the topic
    indexOfSourceMessage - the index of the message in the topic
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedTopicMessageEquals
```
public void verifyReceivedTopicMessageEquals(String nameOfTopic,
                                    int indexOfSourceMessage,
                                    MockMessage targetMessage)
```
    Verifies that a received message is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals().
    
    Parameters:
    nameOfTopic - the name of the topic
    indexOfSourceMessage - the index of the received message
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCurrentTopicMessageEquals
```
public void verifyCurrentTopicMessageEquals(int indexOfSession,
                                   int indexOfTopic,
                                   int indexOfSourceMessage,
                                   MockMessage targetMessage)
```
    Verifies that a message in the specified temporary topic is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    indexOfSourceMessage - the index of the message in the topic
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedTopicMessageEquals
```
public void verifyReceivedTopicMessageEquals(int indexOfSession,
                                    int indexOfTopic,
                                    int indexOfSourceMessage,
                                    MockMessage targetMessage)
```
    Verifies that a message received by a temporary topic is equal to the specified message by calling the equals() method. All mock messages provide a suitable implementation of equals(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    indexOfSourceMessage - the index of the received message
    targetMessage - the message that will be used for comparison
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCurrentTopicMessages
```
public void verifyNumberOfCurrentTopicMessages(String nameOfTopic,
                                      int numberOfMessages)
```
    Verifies the number of messages in a topic.
    
    Parameters:
    nameOfTopic - the name of the topic
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfReceivedTopicMessages
```
public void verifyNumberOfReceivedTopicMessages(String nameOfTopic,
                                       int numberOfMessages)
```
    Verifies the number of messages received by a topic.
    
    Parameters:
    nameOfTopic - the name of the topic
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCurrentTopicMessages
```
public void verifyNumberOfCurrentTopicMessages(int indexOfSession,
                                      int indexOfTopic,
                                      int numberOfMessages)
```
    Verifies the number of messages in a temporary topic. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfReceivedTopicMessages
```
public void verifyNumberOfReceivedTopicMessages(int indexOfSession,
                                       int indexOfTopic,
                                       int numberOfMessages)
```
    Verifies the number of messages received by a temporary topic. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    numberOfMessages - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllReceivedTopicMessagesAcknowledged
```
public void verifyAllReceivedTopicMessagesAcknowledged(String nameOfTopic)
```
    Verifies that all received messages of the specified topic are acknowledged.
    
    Parameters:
    nameOfTopic - the name of the topic
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyAllReceivedTopicMessagesAcknowledged
```
public void verifyAllReceivedTopicMessagesAcknowledged(int indexOfSession,
                                              int indexOfTopic)
```
    Verifies that all received messages of the specified temporary topic are acknowledged. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedTopicMessageAcknowledged
```
public void verifyReceivedTopicMessageAcknowledged(String nameOfTopic,
                                          int indexOfMessage)
```
    Verifies that a received message is acknowledged.
    
    Parameters:
    nameOfTopic - the name of the topic
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedTopicMessageNotAcknowledged
```
public void verifyReceivedTopicMessageNotAcknowledged(String nameOfTopic,
                                             int indexOfMessage)
```
    Verifies that a received message is not acknowledged.
    
    Parameters:
    nameOfTopic - the name of the topic
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedTopicMessageAcknowledged
```
public void verifyReceivedTopicMessageAcknowledged(int indexOfSession,
                                          int indexOfTopic,
                                          int indexOfMessage)
```
    Verifies that a message received by a temporary topic is acknowledged. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyReceivedTopicMessageNotAcknowledged
```
public void verifyReceivedTopicMessageNotAcknowledged(int indexOfSession,
                                             int indexOfTopic,
                                             int indexOfMessage)
```
    Verifies that a message received by a temporary topic is not acknowledged. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfTopic - the index of the temporary topic
    indexOfMessage - the index of the received message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedTopicMessages
```
public void verifyNumberOfCreatedTopicMessages(int indexOfSession,
                                      int number)
```
    Verifies the number of messages created with MockSession.createMessage(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedTopicBytesMessages
```
public void verifyNumberOfCreatedTopicBytesMessages(int indexOfSession,
                                           int number)
```
    Verifies the number of bytes messages created with MockSession.createBytesMessage(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of bytes messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedTopicMapMessages
```
public void verifyNumberOfCreatedTopicMapMessages(int indexOfSession,
                                         int number)
```
    Verifies the number of map messages created with MockSession.createMapMessage(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of map messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedTopicTextMessages
```
public void verifyNumberOfCreatedTopicTextMessages(int indexOfSession,
                                          int number)
```
    Verifies the number of text messages created with MockSession.createTextMessage(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of text messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedTopicStreamMessages
```
public void verifyNumberOfCreatedTopicStreamMessages(int indexOfSession,
                                            int number)
```
    Verifies the number of stream messages created with MockSession.createStreamMessage(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of stream messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedTopicObjectMessages
```
public void verifyNumberOfCreatedTopicObjectMessages(int indexOfSession,
                                            int number)
```
    Verifies the number of object messages created with MockSession.createObjectMessage(). The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of object messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicMessageAcknowledged
```
public void verifyCreatedTopicMessageAcknowledged(int indexOfSession,
                                         int indexOfMessage)
```
    Verifies that a message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicMessageNotAcknowledged
```
public void verifyCreatedTopicMessageNotAcknowledged(int indexOfSession,
                                            int indexOfMessage)
```
    Verifies that a message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicBytesMessageAcknowledged
```
public void verifyCreatedTopicBytesMessageAcknowledged(int indexOfSession,
                                              int indexOfMessage)
```
    Verifies that a bytes message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicBytesMessageNotAcknowledged
```
public void verifyCreatedTopicBytesMessageNotAcknowledged(int indexOfSession,
                                                 int indexOfMessage)
```
    Verifies that a bytes message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicMapMessageAcknowledged
```
public void verifyCreatedTopicMapMessageAcknowledged(int indexOfSession,
                                            int indexOfMessage)
```
    Verifies that a map message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicMapMessageNotAcknowledged
```
public void verifyCreatedTopicMapMessageNotAcknowledged(int indexOfSession,
                                               int indexOfMessage)
```
    Verifies that a map message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicTextMessageAcknowledged
```
public void verifyCreatedTopicTextMessageAcknowledged(int indexOfSession,
                                             int indexOfMessage)
```
    Verifies that a text message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicTextMessageNotAcknowledged
```
public void verifyCreatedTopicTextMessageNotAcknowledged(int indexOfSession,
                                                int indexOfMessage)
```
    Verifies that a text message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicStreamMessageAcknowledged
```
public void verifyCreatedTopicStreamMessageAcknowledged(int indexOfSession,
                                               int indexOfMessage)
```
    Verifies that a stream message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicStreamMessageNotAcknowledged
```
public void verifyCreatedTopicStreamMessageNotAcknowledged(int indexOfSession,
                                                  int indexOfMessage)
```
    Verifies that a stream message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicObjectMessageAcknowledged
```
public void verifyCreatedTopicObjectMessageAcknowledged(int indexOfSession,
                                               int indexOfMessage)
```
    Verifies that a object message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTopicObjectMessageNotAcknowledged
```
public void verifyCreatedTopicObjectMessageNotAcknowledged(int indexOfSession,
                                                  int indexOfMessage)
```
    Verifies that a object message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockTopicConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedMessages
```
public void verifyNumberOfCreatedMessages(int indexOfSession,
                                 int number)
```
    Verifies the number of messages created with MockSession.createMessage(). The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedBytesMessages
```
public void verifyNumberOfCreatedBytesMessages(int indexOfSession,
                                      int number)
```
    Verifies the number of bytes messages created with MockSession.createBytesMessage(). The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of bytes messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedMapMessages
```
public void verifyNumberOfCreatedMapMessages(int indexOfSession,
                                    int number)
```
    Verifies the number of map messages created with MockSession.createMapMessage(). The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of map messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedTextMessages
```
public void verifyNumberOfCreatedTextMessages(int indexOfSession,
                                     int number)
```
    Verifies the number of text messages created with MockSession.createTextMessage(). The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of text messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedStreamMessages
```
public void verifyNumberOfCreatedStreamMessages(int indexOfSession,
                                       int number)
```
    Verifies the number of stream messages created with MockSession.createStreamMessage(). The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of stream messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyNumberOfCreatedObjectMessages
```
public void verifyNumberOfCreatedObjectMessages(int indexOfSession,
                                       int number)
```
    Verifies the number of object messages created with MockSession.createObjectMessage(). The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    number - the expected number of object messages
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedMessageAcknowledged
```
public void verifyCreatedMessageAcknowledged(int indexOfSession,
                                    int indexOfMessage)
```
    Verifies that a message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedMessageNotAcknowledged
```
public void verifyCreatedMessageNotAcknowledged(int indexOfSession,
                                       int indexOfMessage)
```
    Verifies that a message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedBytesMessageAcknowledged
```
public void verifyCreatedBytesMessageAcknowledged(int indexOfSession,
                                         int indexOfMessage)
```
    Verifies that a bytes message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedBytesMessageNotAcknowledged
```
public void verifyCreatedBytesMessageNotAcknowledged(int indexOfSession,
                                            int indexOfMessage)
```
    Verifies that a bytes message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedMapMessageAcknowledged
```
public void verifyCreatedMapMessageAcknowledged(int indexOfSession,
                                       int indexOfMessage)
```
    Verifies that a map message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedMapMessageNotAcknowledged
```
public void verifyCreatedMapMessageNotAcknowledged(int indexOfSession,
                                          int indexOfMessage)
```
    Verifies that a map message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTextMessageAcknowledged
```
public void verifyCreatedTextMessageAcknowledged(int indexOfSession,
                                        int indexOfMessage)
```
    Verifies that a text message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedTextMessageNotAcknowledged
```
public void verifyCreatedTextMessageNotAcknowledged(int indexOfSession,
                                           int indexOfMessage)
```
    Verifies that a text message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedStreamMessageAcknowledged
```
public void verifyCreatedStreamMessageAcknowledged(int indexOfSession,
                                          int indexOfMessage)
```
    Verifies that a stream message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedStreamMessageNotAcknowledged
```
public void verifyCreatedStreamMessageNotAcknowledged(int indexOfSession,
                                             int indexOfMessage)
```
    Verifies that a stream message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedObjectMessageAcknowledged
```
public void verifyCreatedObjectMessageAcknowledged(int indexOfSession,
                                          int indexOfMessage)
```
    Verifies that a object message created with MockSession.createMessage() is acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails
  - verifyCreatedObjectMessageNotAcknowledged
```
public void verifyCreatedObjectMessageNotAcknowledged(int indexOfSession,
                                             int indexOfMessage)
```
    Verifies that a object message created with MockSession.createMessage() is not acknowledged. This method makes sense if messages are not cloned when sending them. This is the default, use ConfigurationManager.setDoCloneOnSend(boolean). If messages are cloned, the cloned message is acknowledged instead of the created message. The session has to be created using the current MockConnection.
    
    Parameters:
    indexOfSession - the index of the session
    indexOfMessage - the index of the message
    
    Throws:
    
    VerifyFailedException - if verification fails

Class JMSTestModule

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

JMSTestModule

Method Detail

setCurrentQueueConnectionIndex

getCurrentQueueConnection

setCurrentTopicConnectionIndex

getCurrentTopicConnection

setCurrentConnectionIndex

getCurrentConnection

registerTestMessageListenerForQueue

registerTestMessageListenerForQueue

registerTestMessageListenerForQueue

registerTestMessageListenerForQueue

registerTestMessageListenerForTopic

registerTestMessageListenerForTopic

registerTestMessageListenerForTopic

registerTestMessageListenerForTopic

getDestinationManager

getConfigurationManager

getQueueMessageManager

getTopicMessageManager

getMessageManager

getQueueTransmissionManager

getTopicTransmissionManager

getTransmissionManager

getTransmissionManagerWrapper

getQueueTransmissionManagerWrapper

getTopicTransmissionManagerWrapper

getQueueSessionList

getTopicSessionList

getSessionList

getQueueSession

getTopicSession

getSession

getQueue

getTopic

getTemporaryQueueList

getTemporaryTopicList

getTemporaryQueue

getTemporaryTopic

getCurrentMessageListFromQueue

getCurrentMessageListFromTemporaryQueue

getReceivedMessageListFromQueue

getReceivedMessageListFromTemporaryQueue

getCurrentMessageListFromTopic

getCurrentMessageListFromTemporaryTopic

getReceivedMessageListFromTopic

getReceivedMessageListFromTemporaryTopic

verifyQueueConnectionClosed

verifyQueueConnectionStarted

verifyQueueConnectionStopped

verifyTopicConnectionClosed

verifyTopicConnectionStarted

verifyTopicConnectionStopped

verifyConnectionClosed

verifyConnectionStarted

verifyConnectionStopped

verifyQueueSessionClosed

verifyQueueSessionCommitted

verifyQueueSessionNotCommitted

verifyQueueSessionNumberCommits

verifyQueueSessionRolledBack

verifyQueueSessionNotRolledBack

verifyQueueSessionNumberRollbacks

verifyQueueSessionRecovered

verifyQueueSessionNotRecovered

verifyTopicSessionClosed

verifyTopicSessionCommitted

verifyTopicSessionNotCommitted

verifyTopicSessionNumberCommits

verifyTopicSessionRolledBack

verifyTopicSessionNotRolledBack

verifyTopicSessionNumberRollbacks

verifyTopicSessionRecovered

verifyTopicSessionNotRecovered

verifySessionClosed