JMSTestModule (Mockrunner)

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.mockrunner.jms
Class JMSTestModule

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

public class JMSTestModule
extends java.lang.Object
extends java.lang.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
`JMSTestModule(JMSMockObjectFactory mockFactory)`

Method Summary
`ConfigurationManager`	`getConfigurationManager()` Returns the `ConfigurationManager`.
`MockConnection`	`getCurrentConnection()` Returns the current `MockConnection` based on its index or `null` if no connection was created.
`java.util.List`	`getCurrentMessageListFromQueue(java.lang.String name)` Returns the list of messages that are currently present in the queue or `null` if no such queue exists.
`java.util.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.
`java.util.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.
`java.util.List`	`getCurrentMessageListFromTopic(java.lang.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(java.lang.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.
`java.util.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.
`java.util.List`	`getReceivedMessageListFromQueue(java.lang.String name)` Returns the list of messages that were received by the queue or `null` if no such queue exists.
`java.util.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.
`java.util.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.
`java.util.List`	`getReceivedMessageListFromTopic(java.lang.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.
`java.util.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.
`java.util.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.
`java.util.List`	`getTemporaryTopicList(int indexOfSession)` Returns the list of `MockTemporaryTopic` objects for the specified session.
`MockTopic`	`getTopic(java.lang.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.
`java.util.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, java.lang.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, java.lang.String queueName, boolean transacted, int acknowledgeMode, java.lang.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, java.lang.String queueName, javax.jms.MessageListener listener)` Creates a new session and receiver using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForQueue(java.lang.String queueName, javax.jms.MessageListener listener)` Creates a new connection and uses it for creating a new session and receiver.
`void`	`registerTestMessageListenerForTopic(MockConnection connection, java.lang.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, java.lang.String topicName, boolean transacted, int acknowledgeMode, java.lang.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, java.lang.String topicName, javax.jms.MessageListener listener)` Creates a new session and subscriber using the specified connection and registers the specified listener.
`void`	`registerTestMessageListenerForTopic(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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, java.lang.String name)` Verifies that the specified durable subscriber is closed.
`void`	`verifyDurableTopicSubscriberPresent(int indexOfSession, java.lang.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, java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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, java.lang.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, java.lang.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, java.lang.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, java.lang.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, java.lang.String topicName, int numberOfSubscribers)` Verifies the number of subscribers for the specified session and the specified topic name.
`void`	`verifyQueueBrowserClosed(int indexOfSession, java.lang.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, java.lang.String queueName, int indexOfReceiver)` Verifies that the specified receiver is closed.
`void`	`verifyQueueSenderClosed(int indexOfSession, java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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, java.lang.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, java.lang.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(java.lang.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,
                                                java.lang.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,
                                                java.lang.String queueName,
                                                boolean transacted,
                                                int acknowledgeMode,
                                                javax.jms.MessageListener listener)

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,
                                                java.lang.String queueName,
                                                boolean transacted,
                                                int acknowledgeMode,
                                                java.lang.String messageSelector,
                                                javax.jms.MessageListener listener)

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(java.lang.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,
                                                java.lang.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,
                                                java.lang.String topicName,
                                                boolean transacted,
                                                int acknowledgeMode,
                                                javax.jms.MessageListener listener)

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,
                                                java.lang.String topicName,
                                                boolean transacted,
                                                int acknowledgeMode,
                                                java.lang.String messageSelector,
                                                javax.jms.MessageListener listener)

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)

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)

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 java.util.List getQueueSessionList()

Returns the list of MockQueueSession objects. The sessions have been created using the current MockQueueConnection.

Returns:: the MockQueueSession list

getTopicSessionList

public java.util.List getTopicSessionList()

Returns the list of MockTopicSession objects. The sessions have been created using the current MockTopicConnection.

Returns:: the MockTopicSession list

getSessionList

public java.util.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(java.lang.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(java.lang.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 java.util.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 java.util.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 java.util.List getCurrentMessageListFromQueue(java.lang.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 java.util.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 java.util.List getReceivedMessageListFromQueue(java.lang.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 java.util.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 java.util.List getCurrentMessageListFromTopic(java.lang.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 java.util.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 java.util.List getReceivedMessageListFromTopic(java.lang.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 java.util.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,
                                     java.lang.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,
                                    java.lang.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,
                                        java.lang.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,
                                       java.lang.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,
                                       java.lang.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,
                                      java.lang.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,
                                         java.lang.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,
                                        java.lang.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,
                                      java.lang.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,
                                     java.lang.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,
                                                java.lang.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,
                                                java.lang.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,
                                               java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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(java.lang.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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

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)

Parameters:: indexOfSession - the index of the session; indexOfMessage - the index of the message
Throws:: VerifyFailedException - if verification fails

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

com.mockrunner.jms Class JMSTestModule

JMSTestModule

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

verifySessionCommitted

verifySessionNotCommitted

verifySessionNumberCommits

verifySessionRolledBack

verifySessionNotRolledBack

com.mockrunner.jms
Class JMSTestModule