001 package com.mockrunner.jms;
002
003 import java.util.Iterator;
004 import java.util.List;
005
006 import javax.jms.JMSException;
007 import javax.jms.MessageConsumer;
008 import javax.jms.MessageListener;
009 import javax.jms.Queue;
010 import javax.jms.Session;
011 import javax.jms.Topic;
012
013 import com.mockrunner.base.NestedApplicationException;
014 import com.mockrunner.base.VerifyFailedException;
015 import com.mockrunner.mock.jms.JMSMockObjectFactory;
016 import com.mockrunner.mock.jms.MockConnection;
017 import com.mockrunner.mock.jms.MockMessage;
018 import com.mockrunner.mock.jms.MockMessageConsumer;
019 import com.mockrunner.mock.jms.MockMessageProducer;
020 import com.mockrunner.mock.jms.MockQueue;
021 import com.mockrunner.mock.jms.MockQueueBrowser;
022 import com.mockrunner.mock.jms.MockQueueConnection;
023 import com.mockrunner.mock.jms.MockQueueConnectionFactory;
024 import com.mockrunner.mock.jms.MockQueueReceiver;
025 import com.mockrunner.mock.jms.MockQueueSender;
026 import com.mockrunner.mock.jms.MockQueueSession;
027 import com.mockrunner.mock.jms.MockSession;
028 import com.mockrunner.mock.jms.MockTemporaryQueue;
029 import com.mockrunner.mock.jms.MockTemporaryTopic;
030 import com.mockrunner.mock.jms.MockTopic;
031 import com.mockrunner.mock.jms.MockTopicConnection;
032 import com.mockrunner.mock.jms.MockTopicConnectionFactory;
033 import com.mockrunner.mock.jms.MockTopicPublisher;
034 import com.mockrunner.mock.jms.MockTopicSession;
035 import com.mockrunner.mock.jms.MockTopicSubscriber;
036
037 /**
038 * Module for JMS tests.
039 * Note that all indices are zero based.
040 * Note for JMS 1.1:
041 * If you use {@link MockQueueConnectionFactory} for creating your
042 * connections and session, you have to use the <code>Queue</code>
043 * methods. Same with {@link MockTopicConnectionFactory}.
044 * The methods without <code>Queue</code> and <code>Topic</code>
045 * in the method name are for connections and sessions that were
046 * created using the {@link com.mockrunner.mock.jms.MockConnectionFactory}.
047 * {@link com.mockrunner.mock.jms.MockConnectionFactory}
048 * also implements <code>QueueConnectionFactory</code> and
049 * <code>TopicConnectionFactory</code> and can be used to create queue and
050 * topic connections as well as generic JMS 1.1 connections. However, the
051 * <code>Queue</code> methods (e.g. {@link #verifyAllQueueReceiversClosed})
052 * only work, if you use {@link MockQueueConnectionFactory}.
053 */
054 public class JMSTestModule
055 {
056 private JMSMockObjectFactory mockFactory;
057 private int currentQueueConnectionIndex;
058 private int currentTopicConnectionIndex;
059 private int currentConnectionIndex;
060
061 public JMSTestModule(JMSMockObjectFactory mockFactory)
062 {
063 this.mockFactory = mockFactory;
064 currentQueueConnectionIndex = -1;
065 currentTopicConnectionIndex = -1;
066 currentConnectionIndex = -1;
067 }
068
069 /**
070 * Sets the index of the queue connection that should be used
071 * for the current test. Per default the latest created connection
072 * is used.
073 * @param connectionIndex the index of the connection
074 */
075 public void setCurrentQueueConnectionIndex(int connectionIndex)
076 {
077 this.currentQueueConnectionIndex = connectionIndex;
078 }
079
080 /**
081 * Returns the current queue connection based on its
082 * index resp. <code>null</code> if no queue connection
083 * was created.
084 * @return the queue connection
085 */
086 public MockQueueConnection getCurrentQueueConnection()
087 {
088 if(0 > currentQueueConnectionIndex)
089 {
090 return mockFactory.getMockQueueConnectionFactory().getLatestQueueConnection();
091 }
092 return mockFactory.getMockQueueConnectionFactory().getQueueConnection(currentQueueConnectionIndex);
093 }
094
095 /**
096 * Sets the index of the topic connection that should be used
097 * for the current test. Per default the latest created connection
098 * is used.
099 * @param connectionIndex the index of the connection
100 */
101 public void setCurrentTopicConnectionIndex(int connectionIndex)
102 {
103 this.currentTopicConnectionIndex = connectionIndex;
104 }
105
106 /**
107 * Returns the current topic connection based on its
108 * index resp. <code>null</code> if no topic connection
109 * was created.
110 * @return the topic connection
111 */
112 public MockTopicConnection getCurrentTopicConnection()
113 {
114 if(0 > currentTopicConnectionIndex)
115 {
116 return mockFactory.getMockTopicConnectionFactory().getLatestTopicConnection();
117 }
118 return mockFactory.getMockTopicConnectionFactory().getTopicConnection(currentTopicConnectionIndex);
119 }
120
121 /**
122 * Sets the index of the connection that should be used
123 * for the current test. Per default the latest created connection
124 * is used.
125 * @param connectionIndex the index of the connection
126 */
127 public void setCurrentConnectionIndex(int connectionIndex)
128 {
129 this.currentConnectionIndex = connectionIndex;
130 }
131
132 /**
133 * Returns the current connection based on its
134 * index resp. <code>null</code> if no connection
135 * was created.
136 * @return the topic connection
137 */
138 public MockConnection getCurrentConnection()
139 {
140 if(0 > currentConnectionIndex)
141 {
142 return mockFactory.getMockConnectionFactory().getLatestConnection();
143 }
144 return mockFactory.getMockConnectionFactory().getConnection(currentConnectionIndex);
145 }
146
147 /**
148 * Creates a new connection and uses it for creating a new session and receiver.
149 * Registers the specified listener. Starts the connection for message
150 * receiving. This method is useful for creating test listeners when
151 * testing senders. It can be used to register message driven beans.
152 * Note that the created connection is the latest created
153 * connection and automatically becomes the default connection for the
154 * test module. The created session is transacted.
155 * This method uses the {@link MockQueueConnectionFactory} for
156 * creating the connection and the session. If you want to use the
157 * {@link com.mockrunner.mock.jms.MockConnectionFactory} you have to create the connection on your own
158 * and call {@link #registerTestMessageListenerForQueue(MockConnection, String, MessageListener)}.
159 * @param queueName the name of the queue used for message receiving
160 * @param listener the listener that should be registered
161 */
162 public void registerTestMessageListenerForQueue(String queueName, MessageListener listener)
163 {
164 try
165 {
166 MockQueueConnectionFactory factory = mockFactory.getMockQueueConnectionFactory();
167 MockQueueConnection connection = (MockQueueConnection)factory.createQueueConnection();
168 registerTestMessageListenerForQueue(connection, queueName, listener);
169 }
170 catch(JMSException exc)
171 {
172 throw new NestedApplicationException(exc);
173 }
174 }
175
176 /**
177 * Creates a new session and receiver using the specified connection and
178 * registers the specified listener. Starts the connection for message
179 * receiving. This method is useful for creating test listeners when
180 * testing senders. It can be used to register message driven beans.
181 * The created session is transacted.
182 * @param connection the connection used for creating the session
183 * @param queueName the name of the queue used for message receiving
184 * @param listener the listener that should be registered
185 */
186 public void registerTestMessageListenerForQueue(MockConnection connection, String queueName, MessageListener listener)
187 {
188 registerTestMessageListenerForQueue(connection, queueName, true, Session.AUTO_ACKNOWLEDGE, listener);
189 }
190
191 /**
192 * Creates a new session and receiver using the specified connection and
193 * registers the specified listener. Starts the connection for message
194 * receiving. This method is useful for creating test listeners when
195 * testing senders. It can be used to register message driven beans.
196 * @param connection the connection used for creating the session
197 * @param queueName the name of the queue used for message receiving
198 * @param transacted should the created session be transacted
199 * @param acknowledgeMode the acknowledge mode of the created session
200 * @param listener the listener that should be registered
201 */
202 public void registerTestMessageListenerForQueue(MockConnection connection, String queueName, boolean transacted, int acknowledgeMode, MessageListener listener)
203 {
204 registerTestMessageListenerForQueue(connection, queueName, transacted, acknowledgeMode, null, listener);
205 }
206
207 /**
208 * Creates a new session and receiver using the specified connection and
209 * registers the specified listener. Starts the connection for message
210 * receiving. This method is useful for creating test listeners when
211 * testing senders. It can be used to register message driven beans.
212 * @param connection the connection used for creating the session
213 * @param queueName the name of the queue used for message receiving
214 * @param transacted should the created session be transacted
215 * @param acknowledgeMode the acknowledge mode of the created session
216 * @param messageSelector the message selector
217 * @param listener the listener that should be registered
218 */
219 public void registerTestMessageListenerForQueue(MockConnection connection, String queueName, boolean transacted, int acknowledgeMode, String messageSelector, MessageListener listener)
220 {
221 try
222 {
223 Queue queue = getDestinationManager().getQueue(queueName);
224 MockSession session = (MockSession)connection.createSession(transacted, acknowledgeMode);
225 MessageConsumer consumer = session.createConsumer(queue, messageSelector);
226 consumer.setMessageListener(listener);
227 connection.start();
228 }
229 catch(JMSException exc)
230 {
231 throw new NestedApplicationException(exc);
232 }
233 }
234
235 /**
236 * Creates a new connection and uses it for creating a new session and subscriber.
237 * Registers the specified listener. Starts the connection for message
238 * receiving. This method is useful for creating test listeners when
239 * testing publishers. It can be used to resgister message driven beans.
240 * Note that the created connection is the latest created
241 * connection and automatically becomes the default connection for the
242 * test module. The created session is transacted.
243 * This method uses the {@link MockTopicConnectionFactory} for
244 * creating the connection and the session. If you want to use the
245 * {@link com.mockrunner.mock.jms.MockConnectionFactory} you have to create the connection on your own
246 * and call {@link #registerTestMessageListenerForTopic(MockConnection, String, MessageListener)}.
247 * @param topicName the name of the topic used for message receiving
248 * @param listener the listener that should be registered
249 */
250 public void registerTestMessageListenerForTopic(String topicName, MessageListener listener)
251 {
252 try
253 {
254 MockTopicConnectionFactory factory = mockFactory.getMockTopicConnectionFactory();
255 MockTopicConnection connection = (MockTopicConnection)factory.createTopicConnection();
256 registerTestMessageListenerForTopic(connection, topicName, listener);
257 }
258 catch(JMSException exc)
259 {
260 throw new NestedApplicationException(exc);
261 }
262 }
263
264 /**
265 * Creates a new session and subscriber using the specified connection and
266 * registers the specified listener. Starts the connection for message
267 * receiving. This method is useful for creating test listeners when
268 * testing publishers. It can be used to resgister message driven beans.
269 * The created session is transacted.
270 * @param connection the connection used for creating the session
271 * @param topicName the name of the topic used for message receiving
272 * @param listener the listener that should be registered
273 */
274 public void registerTestMessageListenerForTopic(MockConnection connection, String topicName, MessageListener listener)
275 {
276 registerTestMessageListenerForTopic(connection, topicName, true, Session.AUTO_ACKNOWLEDGE, listener);
277 }
278
279 /**
280 * Creates a new session and subscriber using the specified connection and
281 * registers the specified listener. Starts the connection for message
282 * receiving. This method is useful for creating test listeners when
283 * testing publishers. It can be used to resgister message driven beans.
284 * @param connection the connection used for creating the session
285 * @param topicName the name of the topic used for message receiving
286 * @param transacted should the created session be transacted
287 * @param acknowledgeMode the acknowledge mode of the created session
288 * @param listener the listener that should be registered
289 */
290 public void registerTestMessageListenerForTopic(MockConnection connection, String topicName, boolean transacted, int acknowledgeMode, MessageListener listener)
291 {
292 registerTestMessageListenerForTopic(connection, topicName, transacted, acknowledgeMode, null, listener);
293 }
294
295 /**
296 * Creates a new session and subscriber using the specified connection and
297 * registers the specified listener. Starts the connection for message
298 * receiving. This method is useful for creating test listeners when
299 * testing publishers. It can be used to resgister message driven beans.
300 * @param connection the connection used for creating the session
301 * @param topicName the name of the topic used for message receiving
302 * @param transacted should the created session be transacted
303 * @param acknowledgeMode the acknowledge mode of the created session
304 * @param messageSelector the message selector
305 * @param listener the listener that should be registered
306 */
307 public void registerTestMessageListenerForTopic(MockConnection connection, String topicName, boolean transacted, int acknowledgeMode, String messageSelector, MessageListener listener)
308 {
309 try
310 {
311 Topic topic = getDestinationManager().getTopic(topicName);
312 MockSession session = (MockSession)connection.createSession(transacted, acknowledgeMode);
313 MessageConsumer consumer = session.createConsumer(topic, messageSelector);
314 consumer.setMessageListener(listener);
315 connection.start();
316 }
317 catch(JMSException exc)
318 {
319 throw new NestedApplicationException(exc);
320 }
321 }
322
323 /**
324 * Returns the {@link DestinationManager}.
325 * @return the {@link DestinationManager}
326 */
327 public DestinationManager getDestinationManager()
328 {
329 return mockFactory.getDestinationManager();
330 }
331
332 /**
333 * Returns the {@link ConfigurationManager}.
334 * @return the {@link ConfigurationManager}
335 */
336 public ConfigurationManager getConfigurationManager()
337 {
338 return mockFactory.getConfigurationManager();
339 }
340
341 /**
342 * Returns the {@link MessageManager} for the specified session
343 * or <code>null</code> if the session does not exist. The returned
344 * {@link MessageManager} is used to keep track of messages sent
345 * to queues.
346 * @param indexOfSession the index of the session
347 * @return the {@link MessageManager}
348 */
349 public MessageManager getQueueMessageManager(int indexOfSession)
350 {
351 MockQueueSession session = getQueueSession(indexOfSession);
352 if(null == session) return null;
353 return session.getMessageManager();
354 }
355
356 /**
357 * Returns the {@link MessageManager} for the specified session
358 * or <code>null</code> if the session does not exist. The returned
359 * {@link MessageManager} is used to keep track of messages sent
360 * to topics.
361 * @param indexOfSession the index of the session
362 * @return the {@link MessageManager}
363 */
364 public MessageManager getTopicMessageManager(int indexOfSession)
365 {
366 MockTopicSession session = getTopicSession(indexOfSession);
367 if(null == session) return null;
368 return session.getMessageManager();
369 }
370
371 /**
372 * Returns the {@link MessageManager} for the specified session
373 * or <code>null</code> if the session does not exist. The returned
374 * {@link MessageManager} is used to keep track of messages sent
375 * to topics.
376 * @param indexOfSession the index of the session
377 * @return the {@link MessageManager}
378 */
379 public MessageManager getMessageManager(int indexOfSession)
380 {
381 MockSession session = getSession(indexOfSession);
382 if(null == session) return null;
383 return session.getMessageManager();
384 }
385
386 /**
387 * Returns the {@link QueueTransmissionManager} for the specified session
388 * or <code>null</code> if the session does not exist.
389 * The session has to be created using the current {@link MockQueueConnection}.
390 * @param indexOfSession the index of the session
391 * @return the {@link QueueTransmissionManager}
392 */
393 public QueueTransmissionManager getQueueTransmissionManager(int indexOfSession)
394 {
395 MockQueueSession session = getQueueSession(indexOfSession);
396 if(null == session) return null;
397 return session.getQueueTransmissionManager();
398 }
399
400 /**
401 * Returns the {@link TopicTransmissionManager} for the specified session
402 * or <code>null</code> if the session does not exist.
403 * The session has to be created using the current {@link MockTopicConnection}.
404 * @param indexOfSession the index of the session
405 * @return the {@link TopicTransmissionManager}
406 */
407 public TopicTransmissionManager getTopicTransmissionManager(int indexOfSession)
408 {
409 MockTopicSession session = getTopicSession(indexOfSession);
410 if(null == session) return null;
411 return session.getTopicTransmissionManager();
412 }
413
414 /**
415 * @deprecated use {@link #getTransmissionManagerWrapper}
416 */
417 public TransmissionManagerWrapper getTransmissionManager(int indexOfSession)
418 {
419 return getTransmissionManagerWrapper(indexOfSession);
420 }
421
422 /**
423 * Returns the {@link TransmissionManagerWrapper} for the specified session
424 * or <code>null</code> if the session does not exist.
425 * The session has to be created using the current {@link MockConnection}.
426 * @param indexOfSession the index of the session
427 * @return the {@link TransmissionManagerWrapper}
428 */
429 public TransmissionManagerWrapper getTransmissionManagerWrapper(int indexOfSession)
430 {
431 MockSession session = getSession(indexOfSession);
432 if(null == session) return null;
433 return session.getTransmissionManagerWrapper();
434 }
435
436 /**
437 * Returns the {@link TransmissionManagerWrapper} for the specified session
438 * or <code>null</code> if the session does not exist.
439 * The session has to be created using the current {@link MockQueueConnection}.
440 * @param indexOfSession the index of the session
441 * @return the {@link TransmissionManagerWrapper}
442 */
443 public TransmissionManagerWrapper getQueueTransmissionManagerWrapper(int indexOfSession)
444 {
445 MockQueueSession session = getQueueSession(indexOfSession);
446 if(null == session) return null;
447 return session.getTransmissionManagerWrapper();
448 }
449
450 /**
451 * Returns the {@link TransmissionManagerWrapper} for the specified session
452 * or <code>null</code> if the session does not exist.
453 * The session has to be created using the current {@link MockTopicConnection}.
454 * @param indexOfSession the index of the session
455 * @return the {@link TransmissionManagerWrapper}
456 */
457 public TransmissionManagerWrapper getTopicTransmissionManagerWrapper(int indexOfSession)
458 {
459 MockTopicSession session = getTopicSession(indexOfSession);
460 if(null == session) return null;
461 return session.getTransmissionManagerWrapper();
462 }
463
464 /**
465 * Returns the list of {@link MockQueueSession} objects.
466 * @return the {@link MockQueueSession} list
467 */
468 public List getQueueSessionList()
469 {
470 if(null == getCurrentQueueConnection()) return null;
471 return getCurrentQueueConnection().getQueueSessionList();
472 }
473
474 /**
475 * Returns the list of {@link MockTopicSession} objects.
476 * @return the {@link MockTopicSession} list
477 */
478 public List getTopicSessionList()
479 {
480 if(null == getCurrentTopicConnection()) return null;
481 return getCurrentTopicConnection().getTopicSessionList();
482 }
483
484 /**
485 * Returns the list of {@link MockSession} objects.
486 * @return the {@link MockSession} list
487 */
488 public List getSessionList()
489 {
490 if(null == getCurrentConnection()) return null;
491 return getCurrentConnection().getSessionList();
492 }
493
494 /**
495 * Returns the {@link MockQueueSession} for the specified index
496 * or <code>null</code> if the session does not exist.
497 * The session has to be created using the current {@link MockQueueConnection}.
498 * @param indexOfSession the index of the session
499 * @return the {@link MockQueueSession}
500 */
501 public MockQueueSession getQueueSession(int indexOfSession)
502 {
503 if(null == getCurrentQueueConnection()) return null;
504 return getCurrentQueueConnection().getQueueSession(indexOfSession);
505 }
506
507 /**
508 * Returns the {@link MockTopicSession} for the specified index
509 * or <code>null</code> if the session does not exist.
510 * The session has to be created using the current {@link MockTopicConnection}.
511 * @param indexOfSession the index of the session
512 * @return the {@link MockTopicSession}
513 */
514 public MockTopicSession getTopicSession(int indexOfSession)
515 {
516 if(null == getCurrentTopicConnection()) return null;
517 return getCurrentTopicConnection().getTopicSession(indexOfSession);
518 }
519
520 /**
521 * Returns the {@link MockSession} for the specified index
522 * or <code>null</code> if the session does not exist.
523 * The session has to be created using the current {@link MockConnection}.
524 * @param indexOfSession the index of the session
525 * @return the {@link MockSession}
526 */
527 public MockSession getSession(int indexOfSession)
528 {
529 if(null == getCurrentConnection()) return null;
530 return getCurrentConnection().getSession(indexOfSession);
531 }
532
533 /**
534 * Returns the {@link MockQueue} with the specified name
535 * or <code>null</code> if no such queue exists.
536 * @param name the name of the queue
537 * @return the {@link MockQueue}
538 */
539 public MockQueue getQueue(String name)
540 {
541 return getDestinationManager().getQueue(name);
542 }
543
544 /**
545 * Returns the {@link MockTopic} with the specified name
546 * or <code>null</code> if no such topic exists.
547 * @param name the name of the topic
548 * @return the {@link MockTopic}
549 */
550 public MockTopic getTopic(String name)
551 {
552 return getDestinationManager().getTopic(name);
553 }
554
555 /**
556 * Returns the list of {@link MockTemporaryQueue} objects
557 * for the specified session. The session has to be created using
558 * the current {@link MockQueueConnection}.
559 * @param indexOfSession the index of the session
560 * @return the {@link MockTemporaryQueue} list
561 */
562 public List getTemporaryQueueList(int indexOfSession)
563 {
564 MockQueueSession session = getQueueSession(indexOfSession);
565 if(null == session) return null;
566 return session.getTemporaryQueueList();
567 }
568
569 /**
570 * Returns the list of {@link MockTemporaryTopic} objects
571 * for the specified session. The session has to be created using
572 * the current {@link MockTopicConnection}.
573 * @param indexOfSession the index of the session
574 * @return the {@link MockTemporaryTopic} list
575 */
576 public List getTemporaryTopicList(int indexOfSession)
577 {
578 MockTopicSession session = getTopicSession(indexOfSession);
579 if(null == session) return null;
580 return session.getTemporaryTopicList();
581 }
582
583 /**
584 * Returns the {@link MockTemporaryQueue} with the specified index
585 * for the specified session. Returns <code>null</code> if no such
586 * temporary queue exists. The session has to be created using
587 * the current {@link MockQueueConnection}.
588 * @param indexOfSession the index of the session
589 * @param indexOfQueue the index of the temporary queue
590 * @return the {@link MockTemporaryQueue}
591 */
592 public MockTemporaryQueue getTemporaryQueue(int indexOfSession, int indexOfQueue)
593 {
594 MockQueueSession session = getQueueSession(indexOfSession);
595 if(null == session) return null;
596 return session.getTemporaryQueue(indexOfQueue);
597 }
598
599 /**
600 * Returns the {@link MockTemporaryTopic} with the specified index
601 * for the specified session. Returns <code>null</code> if no such
602 * temporary queue exists. The session has to be created using
603 * the current {@link MockTopicConnection}.
604 * @param indexOfSession the index of the session
605 * @param indexOfTopic the index of the temporary queue
606 * @return the {@link MockTemporaryTopic}
607 */
608 public MockTemporaryTopic getTemporaryTopic(int indexOfSession, int indexOfTopic)
609 {
610 MockTopicSession session = getTopicSession(indexOfSession);
611 if(null == session) return null;
612 return session.getTemporaryTopic(indexOfTopic);
613 }
614
615 /**
616 * Returns the list of messages that are currently present in the queue
617 * resp. <code>null</code> if no such queue exists.
618 * @param name the name of the queue
619 * @return the list of messages
620 */
621 public List getCurrentMessageListFromQueue(String name)
622 {
623 MockQueue queue = getQueue(name);
624 if(null == queue) return null;
625 return queue.getCurrentMessageList();
626 }
627
628 /**
629 * Returns the list of messages that are currently present in the
630 * temporary queue resp. <code>null</code> if no such queue exists.
631 * The session has to be created using the current {@link MockQueueConnection}.
632 * @param indexOfSession the index of the session
633 * @param indexOfQueue the index of the temporary queue
634 * @return the list of messages
635 */
636 public List getCurrentMessageListFromTemporaryQueue(int indexOfSession, int indexOfQueue)
637 {
638 MockTemporaryQueue queue = getTemporaryQueue(indexOfSession, indexOfQueue);
639 if(null == queue) return null;
640 return queue.getCurrentMessageList();
641 }
642
643 /**
644 * Returns the list of messages that were received by the queue
645 * resp. <code>null</code> if no such queue exists.
646 * @param name the name of the queue
647 * @return the list of messages
648 */
649 public List getReceivedMessageListFromQueue(String name)
650 {
651 MockQueue queue = getQueue(name);
652 if(null == queue) return null;
653 return queue.getReceivedMessageList();
654 }
655
656 /**
657 * Returns the list of messages that were received by the
658 * temporary queue resp. <code>null</code> if no such queue exists.
659 * The session has to be created using the current {@link MockQueueConnection}.
660 * @param indexOfSession the index of the session
661 * @param indexOfQueue the index of the temporary queue
662 * @return the list of messages
663 */
664 public List getReceivedMessageListFromTemporaryQueue(int indexOfSession, int indexOfQueue)
665 {
666 MockTemporaryQueue queue = getTemporaryQueue(indexOfSession, indexOfQueue);
667 if(null == queue) return null;
668 return queue.getReceivedMessageList();
669 }
670
671 /**
672 * Returns the list of messages that are currently present in the topic
673 * resp. <code>null</code> if no such topic exists.
674 * @param name the name of the queue
675 * @return the list of messages
676 */
677 public List getCurrentMessageListFromTopic(String name)
678 {
679 MockTopic topic = getTopic(name);
680 if(null == topic) return null;
681 return topic.getCurrentMessageList();
682 }
683
684 /**
685 * Returns the list of messages that are currently present in the
686 * temporary topic resp. <code>null</code> if no such topic exists.
687 * The session has to be created using the current {@link MockTopicConnection}.
688 * @param indexOfSession the index of the session
689 * @param indexOfTopic the index of the temporary topic
690 * @return the list of messages
691 */
692 public List getCurrentMessageListFromTemporaryTopic(int indexOfSession, int indexOfTopic)
693 {
694 MockTemporaryTopic topic = getTemporaryTopic(indexOfSession, indexOfTopic);
695 if(null == topic) return null;
696 return topic.getCurrentMessageList();
697 }
698
699 /**
700 * Returns the list of messages that were received by the topic
701 * resp. <code>null</code> if no such topic exists.
702 * @param name the name of the topic
703 * @return the list of messages
704 */
705 public List getReceivedMessageListFromTopic(String name)
706 {
707 MockTopic topic = getTopic(name);
708 if(null == topic) return null;
709 return topic.getReceivedMessageList();
710 }
711
712 /**
713 * Returns the list of messages that were received by the
714 * temporary topic resp. <code>null</code> if no such topic exists.
715 * The session has to be created using the current {@link MockTopicConnection}.
716 * @param indexOfSession the index of the session
717 * @param indexOfTopic the index of the temporary topic
718 * @return the list of messages
719 */
720 public List getReceivedMessageListFromTemporaryTopic(int indexOfSession, int indexOfTopic)
721 {
722 MockTemporaryTopic topic = getTemporaryTopic(indexOfSession, indexOfTopic);
723 if(null == topic) return null;
724 return topic.getReceivedMessageList();
725 }
726
727 /**
728 * Verifies that the queue connection is closed.
729 * @throws VerifyFailedException if verification fails
730 */
731 public void verifyQueueConnectionClosed()
732 {
733 if(null == getCurrentQueueConnection())
734 {
735 throw new VerifyFailedException("No QueueConnection present.");
736 }
737 if(!getCurrentQueueConnection().isClosed())
738 {
739 throw new VerifyFailedException("QueueConnection is not closed.");
740 }
741 }
742
743 /**
744 * Verifies that the queue connection is started.
745 * @throws VerifyFailedException if verification fails
746 */
747 public void verifyQueueConnectionStarted()
748 {
749 if(null == getCurrentQueueConnection())
750 {
751 throw new VerifyFailedException("No QueueConnection present.");
752 }
753 if(!getCurrentQueueConnection().isStarted())
754 {
755 throw new VerifyFailedException("QueueConnection is not started.");
756 }
757 }
758
759 /**
760 * Verifies that the queue connection is stopped.
761 * @throws VerifyFailedException if verification fails
762 */
763 public void verifyQueueConnectionStopped()
764 {
765 if(null == getCurrentQueueConnection())
766 {
767 throw new VerifyFailedException("No QueueConnection present.");
768 }
769 if(!getCurrentQueueConnection().isStopped())
770 {
771 throw new VerifyFailedException("QueueConnection is not stopped.");
772 }
773 }
774
775 /**
776 * Verifies that the topic connection is closed.
777 * @throws VerifyFailedException if verification fails
778 */
779 public void verifyTopicConnectionClosed()
780 {
781 if(null == getCurrentTopicConnection())
782 {
783 throw new VerifyFailedException("No TopicConnection present.");
784 }
785 if(!getCurrentTopicConnection().isClosed())
786 {
787 throw new VerifyFailedException("TopicConnection is not closed.");
788 }
789 }
790
791 /**
792 * Verifies that the topic connection is started.
793 * @throws VerifyFailedException if verification fails
794 */
795 public void verifyTopicConnectionStarted()
796 {
797 if(null == getCurrentTopicConnection())
798 {
799 throw new VerifyFailedException("No TopicConnection present.");
800 }
801 if(!getCurrentTopicConnection().isStarted())
802 {
803 throw new VerifyFailedException("TopicConnection is not started.");
804 }
805 }
806
807 /**
808 * Verifies that the topic connection is stopped.
809 * @throws VerifyFailedException if verification fails
810 */
811 public void verifyTopicConnectionStopped()
812 {
813 if(null == getCurrentTopicConnection())
814 {
815 throw new VerifyFailedException("No TopicConnection present.");
816 }
817 if(!getCurrentTopicConnection().isStopped())
818 {
819 throw new VerifyFailedException("TopicConnection is not stopped.");
820 }
821 }
822
823 /**
824 * Verifies that the current connection is closed.
825 * @throws VerifyFailedException if verification fails
826 */
827 public void verifyConnectionClosed()
828 {
829 if(null == getCurrentConnection())
830 {
831 throw new VerifyFailedException("No Connection present.");
832 }
833 if(!getCurrentConnection().isClosed())
834 {
835 throw new VerifyFailedException("Connection is not closed.");
836 }
837 }
838
839 /**
840 * Verifies that the current connection is started.
841 * @throws VerifyFailedException if verification fails
842 */
843 public void verifyConnectionStarted()
844 {
845 if(null == getCurrentConnection())
846 {
847 throw new VerifyFailedException("No Connection present.");
848 }
849 if(!getCurrentConnection().isStarted())
850 {
851 throw new VerifyFailedException("Connection is not started.");
852 }
853 }
854
855 /**
856 * Verifies that the current connection is stopped.
857 * @throws VerifyFailedException if verification fails
858 */
859 public void verifyConnectionStopped()
860 {
861 if(null == getCurrentConnection())
862 {
863 throw new VerifyFailedException("No Connection present.");
864 }
865 if(!getCurrentConnection().isStopped())
866 {
867 throw new VerifyFailedException("Connection is not stopped.");
868 }
869 }
870
871 /**
872 * Verifies that the queue session with the specified index is
873 * closed.
874 * @param indexOfSession the index of the session
875 * @throws VerifyFailedException if verification fails
876 */
877 public void verifyQueueSessionClosed(int indexOfSession)
878 {
879 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
880 if(!session.isClosed())
881 {
882 throw new VerifyFailedException("QueueSession with index " + indexOfSession + " is not closed.");
883 }
884 }
885
886 /**
887 * Verifies that the queue session with the specified index was
888 * committed.
889 * @param indexOfSession the index of the session
890 * @throws VerifyFailedException if verification fails
891 */
892 public void verifyQueueSessionCommitted(int indexOfSession)
893 {
894 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
895 if(!session.isCommitted())
896 {
897 throw new VerifyFailedException("QueueSession is not committed.");
898 }
899 }
900
901 /**
902 * Verifies that the queue session with the specified index was
903 * not committed.
904 * @param indexOfSession the index of the session
905 * @throws VerifyFailedException if verification fails
906 */
907 public void verifyQueueSessionNotCommitted(int indexOfSession)
908 {
909 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
910 if(session.isCommitted())
911 {
912 throw new VerifyFailedException("QueueSession is committed.");
913 }
914 }
915
916 /**
917 * Verifies the number of commits of the queue session with the specified index.
918 * @param indexOfSession the index of the session
919 * @param numberOfCommits the expected number of commits
920 * @throws VerifyFailedException if verification fails
921 */
922 public void verifyQueueSessionNumberCommits(int indexOfSession, int numberOfCommits)
923 {
924 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
925 if(numberOfCommits != session.getNumberCommits())
926 {
927 throw new VerifyFailedException("QueueSession was commited " + session.getNumberCommits() + " times, expected " + numberOfCommits + " times");
928 }
929 }
930
931 /**
932 * Verifies that the queue session with the specified index was
933 * rolled back.
934 * @param indexOfSession the index of the session
935 * @throws VerifyFailedException if verification fails
936 */
937 public void verifyQueueSessionRolledBack(int indexOfSession)
938 {
939 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
940 if(!session.isRolledBack())
941 {
942 throw new VerifyFailedException("QueueSession is not rolled back.");
943 }
944 }
945
946 /**
947 * Verifies that the queue session with the specified index was
948 * not rolled back.
949 * @param indexOfSession the index of the session
950 * @throws VerifyFailedException if verification fails
951 */
952 public void verifyQueueSessionNotRolledBack(int indexOfSession)
953 {
954 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
955 if(session.isRolledBack())
956 {
957 throw new VerifyFailedException("QueueSession is rolled back.");
958 }
959 }
960
961 /**
962 * Verifies the number of rollbacks of the queue session with the specified index.
963 * @param indexOfSession the index of the session
964 * @param numberOfRollbacks the expected number of rollbacks
965 * @throws VerifyFailedException if verification fails
966 */
967 public void verifyQueueSessionNumberRollbacks(int indexOfSession, int numberOfRollbacks)
968 {
969 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
970 if(numberOfRollbacks != session.getNumberRollbacks())
971 {
972 throw new VerifyFailedException("QueueSession was rolled back " + session.getNumberRollbacks() + " times, expected " + numberOfRollbacks + " times");
973 }
974 }
975
976 /**
977 * Verifies that the queue session with the specified index was
978 * recovered.
979 * @param indexOfSession the index of the session
980 * @throws VerifyFailedException if verification fails
981 */
982 public void verifyQueueSessionRecovered(int indexOfSession)
983 {
984 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
985 if(!session.isRecovered())
986 {
987 throw new VerifyFailedException("QueueSession is not recovered.");
988 }
989 }
990
991 /**
992 * Verifies that the queue session with the specified index was
993 * not recovered.
994 * @param indexOfSession the index of the session
995 * @throws VerifyFailedException if verification fails
996 */
997 public void verifyQueueSessionNotRecovered(int indexOfSession)
998 {
999 MockQueueSession session = checkAndGetQueueSessionByIndex(indexOfSession);
1000 if(session.isRecovered())
1001 {
1002 throw new VerifyFailedException("QueueSession is recovered.");
1003 }
1004 }
1005
1006 /**
1007 * Verifies that the topic session with the specified index is
1008 * closed.
1009 * @param indexOfSession the index of the session
1010 * @throws VerifyFailedException if verification fails
1011 */
1012 public void verifyTopicSessionClosed(int indexOfSession)
1013 {
1014 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1015 if(!session.isClosed())
1016 {
1017 throw new VerifyFailedException("TopicSession with index " + indexOfSession + " is not closed.");
1018 }
1019 }
1020
1021 /**
1022 * Verifies that the topic session with the specified index was
1023 * committed.
1024 * @param indexOfSession the index of the session
1025 * @throws VerifyFailedException if verification fails
1026 */
1027 public void verifyTopicSessionCommitted(int indexOfSession)
1028 {
1029 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1030 if(!session.isCommitted())
1031 {
1032 throw new VerifyFailedException("TopicSession is not committed.");
1033 }
1034 }
1035
1036 /**
1037 * Verifies that the topic session with the specified index was
1038 * not committed.
1039 * @param indexOfSession the index of the session
1040 * @throws VerifyFailedException if verification fails
1041 */
1042 public void verifyTopicSessionNotCommitted(int indexOfSession)
1043 {
1044 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1045 if(session.isCommitted())
1046 {
1047 throw new VerifyFailedException("TopicSession is committed.");
1048 }
1049 }
1050
1051 /**
1052 * Verifies the number of commits of the topic session with the specified index.
1053 * @param indexOfSession the index of the session
1054 * @param numberOfCommits the expected number of commits
1055 * @throws VerifyFailedException if verification fails
1056 */
1057 public void verifyTopicSessionNumberCommits(int indexOfSession, int numberOfCommits)
1058 {
1059 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1060 if(numberOfCommits != session.getNumberCommits())
1061 {
1062 throw new VerifyFailedException("TopicSession was commited " + session.getNumberCommits() + " times, expected " + numberOfCommits + " times");
1063 }
1064 }
1065
1066 /**
1067 * Verifies that the topic session with the specified index was
1068 * rolled back.
1069 * @param indexOfSession the index of the session
1070 * @throws VerifyFailedException if verification fails
1071 */
1072 public void verifyTopicSessionRolledBack(int indexOfSession)
1073 {
1074 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1075 if(!session.isRolledBack())
1076 {
1077 throw new VerifyFailedException("TopicSession is not rolled back.");
1078 }
1079 }
1080
1081 /**
1082 * Verifies that the topic session with the specified index was
1083 * not rolled back.
1084 * @param indexOfSession the index of the session
1085 * @throws VerifyFailedException if verification fails
1086 */
1087 public void verifyTopicSessionNotRolledBack(int indexOfSession)
1088 {
1089 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1090 if(session.isRolledBack())
1091 {
1092 throw new VerifyFailedException("TopicSession is rolled back.");
1093 }
1094 }
1095
1096 /**
1097 * Verifies the number of rollbacks of the topic session with the specified index.
1098 * @param indexOfSession the index of the session
1099 * @param numberOfRollbacks the expected number of rollbacks
1100 * @throws VerifyFailedException if verification fails
1101 */
1102 public void verifyTopicSessionNumberRollbacks(int indexOfSession, int numberOfRollbacks)
1103 {
1104 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1105 if(numberOfRollbacks != session.getNumberRollbacks())
1106 {
1107 throw new VerifyFailedException("TopicSession was rolled back " + session.getNumberRollbacks() + " times, expected " + numberOfRollbacks + " times");
1108 }
1109 }
1110
1111 /**
1112 * Verifies that the topic session with the specified index was
1113 * recovered.
1114 * @param indexOfSession the index of the session
1115 * @throws VerifyFailedException if verification fails
1116 */
1117 public void verifyTopicSessionRecovered(int indexOfSession)
1118 {
1119 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1120 if(!session.isRecovered())
1121 {
1122 throw new VerifyFailedException("TopicSession is not recovered.");
1123 }
1124 }
1125
1126 /**
1127 * Verifies that the topic session with the specified index was
1128 * not recovered.
1129 * @param indexOfSession the index of the session
1130 * @throws VerifyFailedException if verification fails
1131 */
1132 public void verifyTopicSessionNotRecovered(int indexOfSession)
1133 {
1134 MockTopicSession session = checkAndGetTopicSessionByIndex(indexOfSession);
1135 if(session.isRecovered())
1136 {
1137 throw new VerifyFailedException("TopicSession is recovered.");
1138 }
1139 }
1140
1141 /**
1142 * Verifies that the session with the specified index is
1143 * closed.
1144 * @param indexOfSession the index of the session
1145 * @throws VerifyFailedException if verification fails
1146 */
1147 public void verifySessionClosed(int indexOfSession)
1148 {
1149 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1150 if(!session.isClosed())
1151 {
1152 throw new VerifyFailedException("Session with index " + indexOfSession + " is not closed.");
1153 }
1154 }
1155
1156 /**
1157 * Verifies that the session with the specified index was
1158 * committed.
1159 * @param indexOfSession the index of the session
1160 * @throws VerifyFailedException if verification fails
1161 */
1162 public void verifySessionCommitted(int indexOfSession)
1163 {
1164 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1165 if(!session.isCommitted())
1166 {
1167 throw new VerifyFailedException("Session is not committed.");
1168 }
1169 }
1170
1171 /**
1172 * Verifies that the session with the specified index was
1173 * not committed.
1174 * @param indexOfSession the index of the session
1175 * @throws VerifyFailedException if verification fails
1176 */
1177 public void verifySessionNotCommitted(int indexOfSession)
1178 {
1179 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1180 if(session.isCommitted())
1181 {
1182 throw new VerifyFailedException("Session is committed.");
1183 }
1184 }
1185
1186 /**
1187 * Verifies the number of commits of session with the specified index.
1188 * @param indexOfSession the index of the session
1189 * @param numberOfCommits the expected number of commits
1190 * @throws VerifyFailedException if verification fails
1191 */
1192 public void verifySessionNumberCommits(int indexOfSession, int numberOfCommits)
1193 {
1194 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1195 if(numberOfCommits != session.getNumberCommits())
1196 {
1197 throw new VerifyFailedException("Session was commited " + session.getNumberCommits() + " times, expected " + numberOfCommits + " times");
1198 }
1199 }
1200
1201 /**
1202 * Verifies that the session with the specified index was
1203 * rolled back.
1204 * @param indexOfSession the index of the session
1205 * @throws VerifyFailedException if verification fails
1206 */
1207 public void verifySessionRolledBack(int indexOfSession)
1208 {
1209 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1210 if(!session.isRolledBack())
1211 {
1212 throw new VerifyFailedException("Session is not rolled back.");
1213 }
1214 }
1215
1216 /**
1217 * Verifies that the session with the specified index was
1218 * not rolled back.
1219 * @param indexOfSession the index of the session
1220 * @throws VerifyFailedException if verification fails
1221 */
1222 public void verifySessionNotRolledBack(int indexOfSession)
1223 {
1224 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1225 if(session.isRolledBack())
1226 {
1227 throw new VerifyFailedException("Session is rolled back.");
1228 }
1229 }
1230
1231 /**
1232 * Verifies the number of rollbacks of session with the specified index.
1233 * @param indexOfSession the index of the session
1234 * @param numberOfRollbacks the expected number of rollbacks
1235 * @throws VerifyFailedException if verification fails
1236 */
1237 public void verifySessionNumberRollbacks(int indexOfSession, int numberOfRollbacks)
1238 {
1239 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1240 if(numberOfRollbacks != session.getNumberRollbacks())
1241 {
1242 throw new VerifyFailedException("Session was rolled back " + session.getNumberRollbacks() + " times, expected " + numberOfRollbacks + " times");
1243 }
1244 }
1245
1246 /**
1247 * Verifies that the session with the specified index was
1248 * recovered.
1249 * @param indexOfSession the index of the session
1250 * @throws VerifyFailedException if verification fails
1251 */
1252 public void verifySessionRecovered(int indexOfSession)
1253 {
1254 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1255 if(!session.isRecovered())
1256 {
1257 throw new VerifyFailedException("Session is not recovered.");
1258 }
1259 }
1260
1261 /**
1262 * Verifies that the session with the specified index was
1263 * not recovered.
1264 * @param indexOfSession the index of the session
1265 * @throws VerifyFailedException if verification fails
1266 */
1267 public void verifySessionNotRecovered(int indexOfSession)
1268 {
1269 MockSession session = checkAndGetSessionByIndex(indexOfSession);
1270 if(session.isRecovered())
1271 {
1272 throw new VerifyFailedException("Session is recovered.");
1273 }
1274 }
1275
1276 /**
1277 * Verifies that all queue sessions are closed.
1278 * @throws VerifyFailedException if verification fails
1279 */
1280 public void verifyAllQueueSessionsClosed()
1281 {
1282 List queueSessions = getQueueSessionList();
1283 for(int ii = 0; ii < queueSessions.size(); ii++)
1284 {
1285 MockQueueSession currentSession = (MockQueueSession)queueSessions.get(ii);
1286 if(!currentSession.isClosed())
1287 {
1288 throw new VerifyFailedException("QueueSession with index " + ii + " is not closed.");
1289 }
1290 }
1291 }
1292
1293 /**
1294 * Verifies that all queue sessions are recovered.
1295 * @throws VerifyFailedException if verification fails
1296 */
1297 public void verifyAllQueueSessionsRecovered()
1298 {
1299 List queueSessions = getQueueSessionList();
1300 for(int ii = 0; ii < queueSessions.size(); ii++)
1301 {
1302 MockQueueSession currentSession = (MockQueueSession)queueSessions.get(ii);
1303 if(!currentSession.isRecovered())
1304 {
1305 throw new VerifyFailedException("QueueSession with index " + ii + " is not recovered.");
1306 }
1307 }
1308 }
1309
1310 /**
1311 * Verifies that all queue sessions were commited.
1312 * @throws VerifyFailedException if verification fails
1313 */
1314 public void verifyAllQueueSessionsCommitted()
1315 {
1316 List queueSessions = getQueueSessionList();
1317 for(int ii = 0; ii < queueSessions.size(); ii++)
1318 {
1319 MockQueueSession currentSession = (MockQueueSession)queueSessions.get(ii);
1320 if(!currentSession.isCommitted())
1321 {
1322 throw new VerifyFailedException("QueueSession with index " + ii + " is not committed.");
1323 }
1324 }
1325 }
1326
1327 /**
1328 * Verifies that all queue sessions were rolled back.
1329 * @throws VerifyFailedException if verification fails
1330 */
1331 public void verifyAllQueueSessionsRolledBack()
1332 {
1333 List queueSessions = getQueueSessionList();
1334 for(int ii = 0; ii < queueSessions.size(); ii++)
1335 {
1336 MockQueueSession currentSession = (MockQueueSession)queueSessions.get(ii);
1337 if(!currentSession.isRolledBack())
1338 {
1339 throw new VerifyFailedException("QueueSession with index " + ii + " is not rolled back.");
1340 }
1341 }
1342 }
1343
1344 /**
1345 * Verifies that all topic sessions are closed.
1346 * @throws VerifyFailedException if verification fails
1347 */
1348 public void verifyAllTopicSessionsClosed()
1349 {
1350 List topicSessions = getTopicSessionList();
1351 for(int ii = 0; ii < topicSessions.size(); ii++)
1352 {
1353 MockTopicSession currentSession = (MockTopicSession)topicSessions.get(ii);
1354 if(!currentSession.isClosed())
1355 {
1356 throw new VerifyFailedException("TopicSession with index " + ii + " is not closed.");
1357 }
1358 }
1359 }
1360
1361 /**
1362 * Verifies that all topic sessions are recovered.
1363 * @throws VerifyFailedException if verification fails
1364 */
1365 public void verifyAllTopicSessionsRecovered()
1366 {
1367 List topicSessions = getTopicSessionList();
1368 for(int ii = 0; ii < topicSessions.size(); ii++)
1369 {
1370 MockTopicSession currentSession = (MockTopicSession)topicSessions.get(ii);
1371 if(!currentSession.isRecovered())
1372 {
1373 throw new VerifyFailedException("TopicSession with index " + ii + " is not recovered.");
1374 }
1375 }
1376 }
1377
1378 /**
1379 * Verifies that all topic sessions were commited.
1380 * @throws VerifyFailedException if verification fails
1381 */
1382 public void verifyAllTopicSessionsCommitted()
1383 {
1384 List topicSessions = getTopicSessionList();
1385 for(int ii = 0; ii < topicSessions.size(); ii++)
1386 {
1387 MockTopicSession currentSession = (MockTopicSession)topicSessions.get(ii);
1388 if(!currentSession.isCommitted())
1389 {
1390 throw new VerifyFailedException("TopicSession with index " + ii + " is not committed.");
1391 }
1392 }
1393 }
1394
1395 /**
1396 * Verifies that all topic sessions were rolled back.
1397 * @throws VerifyFailedException if verification fails
1398 */
1399 public void verifyAllTopicSessionsRolledBack()
1400 {
1401 List topicSessions = getTopicSessionList();
1402 for(int ii = 0; ii < topicSessions.size(); ii++)
1403 {
1404 MockTopicSession currentSession = (MockTopicSession)topicSessions.get(ii);
1405 if(!currentSession.isRolledBack())
1406 {
1407 throw new VerifyFailedException("TopicSession with index " + ii + " is not rolled back.");
1408 }
1409 }
1410 }
1411
1412 /**
1413 * Verifies that all sessions are closed.
1414 * @throws VerifyFailedException if verification fails
1415 */
1416 public void verifyAllSessionsClosed()
1417 {
1418 List sessions = getSessionList();
1419 for(int ii = 0; ii < sessions.size(); ii++)
1420 {
1421 MockSession currentSession = (MockSession)sessions.get(ii);
1422 if(!currentSession.isClosed())
1423 {
1424 throw new VerifyFailedException("Session with index " + ii + " is not closed.");
1425 }
1426 }
1427 }
1428
1429 /**
1430 * Verifies that all sessions are recovered.
1431 * @throws VerifyFailedException if verification fails
1432 */
1433 public void verifyAllSessionsRecovered()
1434 {
1435 List sessions = getSessionList();
1436 for(int ii = 0; ii < sessions.size(); ii++)
1437 {
1438 MockSession currentSession = (MockSession)sessions.get(ii);
1439 if(!currentSession.isRecovered())
1440 {
1441 throw new VerifyFailedException("Session with index " + ii + " is not recovered.");
1442 }
1443 }
1444 }
1445
1446 /**
1447 * Verifies that all sessions were commited.
1448 * @throws VerifyFailedException if verification fails
1449 */
1450 public void verifyAllSessionsCommitted()
1451 {
1452 List sessions = getSessionList();
1453 for(int ii = 0; ii < sessions.size(); ii++)
1454 {
1455 MockSession currentSession = (MockSession)sessions.get(ii);
1456 if(!currentSession.isCommitted())
1457 {
1458 throw new VerifyFailedException("Session with index " + ii + " is not committed.");
1459 }
1460 }
1461 }
1462
1463 /**
1464 * Verifies that all topic sessions were rolled back.
1465 * @throws VerifyFailedException if verification fails
1466 */
1467 public void verifyAllSessionsRolledBack()
1468 {
1469 List sessions = getSessionList();
1470 for(int ii = 0; ii < sessions.size(); ii++)
1471 {
1472 MockSession currentSession = (MockSession)sessions.get(ii);
1473 if(!currentSession.isRolledBack())
1474 {
1475 throw new VerifyFailedException("Session with index " + ii + " is not rolled back.");
1476 }
1477 }
1478 }
1479
1480 /**
1481 * Verifies the number of producers for the specified session.
1482 * The session has to be created using the current {@link MockConnection}.
1483 * @param indexOfSession the index of the session
1484 * @param numberOfProducers the expected number of producers
1485 * @throws VerifyFailedException if verification fails
1486 */
1487 public void verifyNumberMessageProducers(int indexOfSession, int numberOfProducers)
1488 {
1489 checkAndGetSessionByIndex(indexOfSession);
1490 TransmissionManagerWrapper manager = getTransmissionManagerWrapper(indexOfSession);
1491 if(numberOfProducers != manager.getMessageProducerList().size())
1492 {
1493 throw new VerifyFailedException("Expected " + numberOfProducers + " producers, actually " + manager.getMessageProducerList().size() + " producers present");
1494 }
1495 }
1496
1497 /**
1498 * Verifies that all producers for the specified session are closed.
1499 * The session has to be created using the current {@link MockConnection}.
1500 * @param indexOfSession the index of the session
1501 * @throws VerifyFailedException if verification fails
1502 */
1503 public void verifyAllMessageProducersClosed(int indexOfSession)
1504 {
1505 checkAndGetSessionByIndex(indexOfSession);
1506 TransmissionManagerWrapper manager = getTransmissionManagerWrapper(indexOfSession);
1507 List producers = manager.getMessageProducerList();
1508 for(int ii = 0; ii < producers.size(); ii++)
1509 {
1510 MockMessageProducer currentProducer = (MockMessageProducer)producers.get(ii);
1511 if(!currentProducer.isClosed())
1512 {
1513 throw new VerifyFailedException("MessageProducer with index " + ii + " not closed.");
1514 }
1515 }
1516 }
1517
1518 /**
1519 * Verifies the number of senders for the specified session.
1520 * The session has to be created using the current {@link MockQueueConnection}.
1521 * @param indexOfSession the index of the session
1522 * @param numberOfSenders the expected number of senders
1523 * @throws VerifyFailedException if verification fails
1524 */
1525 public void verifyNumberQueueSenders(int indexOfSession, int numberOfSenders)
1526 {
1527 checkAndGetQueueSessionByIndex(indexOfSession);
1528 TransmissionManagerWrapper manager = getQueueTransmissionManagerWrapper(indexOfSession);
1529 if(numberOfSenders != manager.getQueueSenderList().size())
1530 {
1531 throw new VerifyFailedException("Expected " + numberOfSenders + " senders, actually " + manager.getQueueSenderList().size() + " senders present");
1532 }
1533 }
1534
1535 /**
1536 * Verifies the number of senders for the specified session and
1537 * the specified queue name.
1538 * The session has to be created using the current {@link MockQueueConnection}.
1539 * @param indexOfSession the index of the session
1540 * @param queueName the name of the queue
1541 * @param numberOfSenders the expected number of senders
1542 * @throws VerifyFailedException if verification fails
1543 */
1544 public void verifyNumberQueueSenders(int indexOfSession, String queueName, int numberOfSenders)
1545 {
1546 checkAndGetQueueSessionByIndex(indexOfSession);
1547 checkQueueByName(queueName);
1548 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1549 if(numberOfSenders != manager.getQueueSenderList(queueName).size())
1550 {
1551 throw new VerifyFailedException("Expected " + numberOfSenders + " senders for queue " + queueName + ", actually " + manager.getQueueSenderList(queueName).size() + " senders present");
1552 }
1553 }
1554
1555 /**
1556 * Verifies that the specified sender is closed.
1557 * The session has to be created using the current {@link MockQueueConnection}.
1558 * @param indexOfSession the index of the session
1559 * @param queueName the name of the queue
1560 * @param indexOfSender the index of the sender
1561 * @throws VerifyFailedException if verification fails
1562 */
1563 public void verifyQueueSenderClosed(int indexOfSession, String queueName, int indexOfSender)
1564 {
1565 checkAndGetQueueSessionByIndex(indexOfSession);
1566 checkQueueByName(queueName);
1567 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1568 List senders = manager.getQueueSenderList(queueName);
1569 if(indexOfSender >= senders.size())
1570 {
1571 throw new VerifyFailedException("QueueSender with index " + indexOfSender + " is not present.");
1572 }
1573 MockQueueSender sender = (MockQueueSender)senders.get(indexOfSender);
1574 if(!sender.isClosed())
1575 {
1576 throw new VerifyFailedException("QueueSender of queue " + queueName + " with index " + indexOfSender + " not closed.");
1577 }
1578 }
1579
1580 /**
1581 * Verifies that all senders for the specified session are closed.
1582 * The session has to be created using the current {@link MockQueueConnection}.
1583 * @param indexOfSession the index of the session
1584 * @throws VerifyFailedException if verification fails
1585 */
1586 public void verifyAllQueueSendersClosed(int indexOfSession)
1587 {
1588 checkAndGetQueueSessionByIndex(indexOfSession);
1589 TransmissionManagerWrapper manager = getQueueTransmissionManagerWrapper(indexOfSession);
1590 List senders = manager.getQueueSenderList();
1591 for(int ii = 0; ii < senders.size(); ii++)
1592 {
1593 MockQueueSender currentSender = (MockQueueSender)senders.get(ii);
1594 if(!currentSender.isClosed())
1595 {
1596 throw new VerifyFailedException("QueueSender with index " + ii + " not closed.");
1597 }
1598 }
1599 }
1600
1601 /**
1602 * Verifies the number of publishers for the specified session.
1603 * The session has to be created using the current {@link MockTopicConnection}.
1604 * @param indexOfSession the index of the session
1605 * @param numberOfPublishers the expected number of publishers
1606 * @throws VerifyFailedException if verification fails
1607 */
1608 public void verifyNumberTopicPublishers(int indexOfSession, int numberOfPublishers)
1609 {
1610 checkAndGetTopicSessionByIndex(indexOfSession);
1611 TransmissionManagerWrapper manager = getTopicTransmissionManagerWrapper(indexOfSession);
1612 if(numberOfPublishers != manager.getTopicPublisherList().size())
1613 {
1614 throw new VerifyFailedException("Expected " + numberOfPublishers + " publishers, actually " + manager.getTopicPublisherList().size() + " publishers present");
1615 }
1616 }
1617
1618 /**
1619 * Verifies the number of publishers for the specified session and
1620 * the specified topic name.
1621 * The session has to be created using the current {@link MockTopicConnection}.
1622 * @param indexOfSession the index of the session
1623 * @param topicName the name of the topic
1624 * @param numberOfPublishers the expected number of publishers
1625 * @throws VerifyFailedException if verification fails
1626 */
1627 public void verifyNumberTopicPublishers(int indexOfSession, String topicName, int numberOfPublishers)
1628 {
1629 checkAndGetTopicSessionByIndex(indexOfSession);
1630 checkTopicByName(topicName);
1631 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1632 if(numberOfPublishers != manager.getTopicPublisherList(topicName).size())
1633 {
1634 throw new VerifyFailedException("Expected " + numberOfPublishers + " publishers for topic " + topicName + ", actually " + manager.getTopicPublisherList(topicName).size() + " publishers present");
1635 }
1636 }
1637
1638 /**
1639 * Verifies that the specified publisher is closed.
1640 * The session has to be created using the current {@link MockTopicConnection}.
1641 * @param indexOfSession the index of the session
1642 * @param topicName the name of the topic
1643 * @param indexOfPublisher the index of the publisher
1644 * @throws VerifyFailedException if verification fails
1645 */
1646 public void verifyTopicPublisherClosed(int indexOfSession, String topicName, int indexOfPublisher)
1647 {
1648 checkAndGetTopicSessionByIndex(indexOfSession);
1649 checkTopicByName(topicName);
1650 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1651 List publishers = manager.getTopicPublisherList(topicName);
1652 if(indexOfPublisher >= publishers.size())
1653 {
1654 throw new VerifyFailedException("TopicPublisher with index " + indexOfPublisher + " is not present.");
1655 }
1656 MockTopicPublisher publisher = (MockTopicPublisher)publishers.get(indexOfPublisher);
1657 if(!publisher.isClosed())
1658 {
1659 throw new VerifyFailedException("TopicPublisher of topic " + topicName + " with index " + indexOfPublisher + " not closed.");
1660 }
1661 }
1662
1663 /**
1664 * Verifies that all publishers for the specified session are closed.
1665 * The session has to be created using the current {@link MockTopicConnection}.
1666 * @param indexOfSession the index of the session
1667 * @throws VerifyFailedException if verification fails
1668 */
1669 public void verifyAllTopicPublishersClosed(int indexOfSession)
1670 {
1671 checkAndGetTopicSessionByIndex(indexOfSession);
1672 TransmissionManagerWrapper manager = getTopicTransmissionManagerWrapper(indexOfSession);
1673 List publishers = manager.getTopicPublisherList();
1674 for(int ii = 0; ii < publishers.size(); ii++)
1675 {
1676 MockTopicPublisher currentPublisher = (MockTopicPublisher)publishers.get(ii);
1677 if(!currentPublisher.isClosed())
1678 {
1679 throw new VerifyFailedException("TopicPublisher with index " + ii + " not closed.");
1680 }
1681 }
1682 }
1683
1684 /**
1685 * Verifies the number of consumers for the specified session.
1686 * The session has to be created using the current {@link MockConnection}.
1687 * @param indexOfSession the index of the session
1688 * @param numberOfConsumers the expected number of consumers
1689 * @throws VerifyFailedException if verification fails
1690 */
1691 public void verifyNumberMessageConsumers(int indexOfSession, int numberOfConsumers)
1692 {
1693 checkAndGetSessionByIndex(indexOfSession);
1694 TransmissionManagerWrapper manager = getTransmissionManagerWrapper(indexOfSession);
1695 if(numberOfConsumers != manager.getMessageConsumerList().size())
1696 {
1697 throw new VerifyFailedException("Expected " + numberOfConsumers + " consumers, actually " + manager.getMessageConsumerList().size() + " consumers present");
1698 }
1699 }
1700
1701 /**
1702 * Verifies that all consumers for the specified session are closed.
1703 * The session has to be created using the current {@link MockConnection}.
1704 * @param indexOfSession the index of the session
1705 * @throws VerifyFailedException if verification fails
1706 */
1707 public void verifyAllMessageConsumersClosed(int indexOfSession)
1708 {
1709 checkAndGetSessionByIndex(indexOfSession);
1710 TransmissionManagerWrapper manager = getTransmissionManagerWrapper(indexOfSession);
1711 List consumers = manager.getMessageConsumerList();
1712 for(int ii = 0; ii < consumers.size(); ii++)
1713 {
1714 MockMessageConsumer currentConsumer = (MockMessageConsumer)consumers.get(ii);
1715 if(!currentConsumer.isClosed())
1716 {
1717 throw new VerifyFailedException("MessageConsumer with index " + ii + " not closed.");
1718 }
1719 }
1720 }
1721
1722 /**
1723 * Verifies the number of receivers for the specified session.
1724 * The session has to be created using the current {@link MockQueueConnection}.
1725 * @param indexOfSession the index of the session
1726 * @param numberOfReceivers the expected number of receivers
1727 * @throws VerifyFailedException if verification fails
1728 */
1729 public void verifyNumberQueueReceivers(int indexOfSession, int numberOfReceivers)
1730 {
1731 checkAndGetQueueSessionByIndex(indexOfSession);
1732 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1733 if(numberOfReceivers != manager.getQueueReceiverList().size())
1734 {
1735 throw new VerifyFailedException("Expected " + numberOfReceivers + " receivers, actually " + manager.getQueueReceiverList().size() + " receivers present");
1736 }
1737 }
1738
1739 /**
1740 * Verifies the number of receivers for the specified session and
1741 * the specified queue name.
1742 * The session has to be created using the current {@link MockQueueConnection}.
1743 * @param indexOfSession the index of the session
1744 * @param queueName the name of the queue
1745 * @param numberOfReceivers the expected number of receivers
1746 * @throws VerifyFailedException if verification fails
1747 */
1748 public void verifyNumberQueueReceivers(int indexOfSession, String queueName, int numberOfReceivers)
1749 {
1750 checkAndGetQueueSessionByIndex(indexOfSession);
1751 checkQueueByName(queueName);
1752 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1753 if(numberOfReceivers != manager.getQueueReceiverList(queueName).size())
1754 {
1755 throw new VerifyFailedException("Expected " + numberOfReceivers + " receivers for queue " + queueName + ", actually " + manager.getQueueReceiverList(queueName).size() + " receivers present");
1756 }
1757 }
1758
1759 /**
1760 * Verifies that the specified receiver is closed.
1761 * The session has to be created using the current {@link MockQueueConnection}.
1762 * @param indexOfSession the index of the session
1763 * @param queueName the name of the queue
1764 * @param indexOfReceiver the index of the receiver
1765 * @throws VerifyFailedException if verification fails
1766 */
1767 public void verifyQueueReceiverClosed(int indexOfSession, String queueName, int indexOfReceiver)
1768 {
1769 checkAndGetQueueSessionByIndex(indexOfSession);
1770 checkQueueByName(queueName);
1771 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1772 List receivers = manager.getQueueReceiverList(queueName);
1773 if(indexOfReceiver >= receivers.size())
1774 {
1775 throw new VerifyFailedException("QueueReceiver with index " + indexOfReceiver + " is not present.");
1776 }
1777 MockQueueReceiver receiver = (MockQueueReceiver)receivers.get(indexOfReceiver);
1778 if(!receiver.isClosed())
1779 {
1780 throw new VerifyFailedException("QueueReceiver of queue " + queueName + " with index " + indexOfReceiver + " not closed.");
1781 }
1782 }
1783
1784 /**
1785 * Verifies that all receivers for the specified session are closed.
1786 * The session has to be created using the current {@link MockQueueConnection}.
1787 * @param indexOfSession the index of the session
1788 * @throws VerifyFailedException if verification fails
1789 */
1790 public void verifyAllQueueReceiversClosed(int indexOfSession)
1791 {
1792 checkAndGetQueueSessionByIndex(indexOfSession);
1793 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1794 List receivers = manager.getQueueReceiverList();
1795 for(int ii = 0; ii < receivers.size(); ii++)
1796 {
1797 MockQueueReceiver currentReceiver = (MockQueueReceiver)receivers.get(ii);
1798 if(!currentReceiver.isClosed())
1799 {
1800 throw new VerifyFailedException("QueueReceiver with index " + ii + " not closed.");
1801 }
1802 }
1803 }
1804
1805 /**
1806 * Verifies the number of subscribers for the specified session.
1807 * The session has to be created using the current {@link MockTopicConnection}.
1808 * @param indexOfSession the index of the session
1809 * @param numberOfSubscribers the expected number of subscribers
1810 * @throws VerifyFailedException if verification fails
1811 */
1812 public void verifyNumberTopicSubscribers(int indexOfSession, int numberOfSubscribers)
1813 {
1814 checkAndGetTopicSessionByIndex(indexOfSession);
1815 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1816 if(numberOfSubscribers != manager.getTopicSubscriberList().size())
1817 {
1818 throw new VerifyFailedException("Expected " + numberOfSubscribers + " subscribers, actually " + manager.getTopicSubscriberList().size() + " subscribers present");
1819 }
1820 }
1821
1822 /**
1823 * Verifies the number of subscribers for the specified session and
1824 * the specified topic name.
1825 * The session has to be created using the current {@link MockTopicConnection}.
1826 * @param indexOfSession the index of the session
1827 * @param topicName the name of the topic
1828 * @param numberOfSubscribers the expected number of subscribers
1829 * @throws VerifyFailedException if verification fails
1830 */
1831 public void verifyNumberTopicSubscribers(int indexOfSession, String topicName, int numberOfSubscribers)
1832 {
1833 checkAndGetTopicSessionByIndex(indexOfSession);
1834 checkTopicByName(topicName);
1835 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1836 if(numberOfSubscribers != manager.getTopicSubscriberList(topicName).size())
1837 {
1838 throw new VerifyFailedException("Expected " + numberOfSubscribers + " subscribers for topic " + topicName + ", actually " + manager.getTopicSubscriberList(topicName).size() + " subscribers present");
1839 }
1840 }
1841
1842 /**
1843 * Verifies that the specified subscriber is closed.
1844 * The session has to be created using the current {@link MockTopicConnection}.
1845 * @param indexOfSession the index of the session
1846 * @param topicName the name of the topic
1847 * @param indexOfSubscriber the index of the receiver
1848 * @throws VerifyFailedException if verification fails
1849 */
1850 public void verifyTopicSubscriberClosed(int indexOfSession, String topicName, int indexOfSubscriber)
1851 {
1852 checkAndGetTopicSessionByIndex(indexOfSession);
1853 checkTopicByName(topicName);
1854 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1855 List subscribers = manager.getTopicSubscriberList(topicName);
1856 if(indexOfSubscriber >= subscribers.size())
1857 {
1858 throw new VerifyFailedException("TopicSubscriber with index " + indexOfSubscriber + " is not present.");
1859 }
1860 MockTopicSubscriber subscriber = (MockTopicSubscriber)subscribers.get(indexOfSubscriber);
1861 if(!subscriber.isClosed())
1862 {
1863 throw new VerifyFailedException("TopicSubscriber of topic " + topicName + " with index " + indexOfSubscriber + " not closed.");
1864 }
1865 }
1866
1867 /**
1868 * Verifies that all subscribers for the specified session are closed.
1869 * The session has to be created using the current {@link MockTopicConnection}.
1870 * @param indexOfSession the index of the session
1871 * @throws VerifyFailedException if verification fails
1872 */
1873 public void verifyAllTopicSubscribersClosed(int indexOfSession)
1874 {
1875 checkAndGetTopicSessionByIndex(indexOfSession);
1876 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1877 List subscribers = manager.getTopicSubscriberList();
1878 for(int ii = 0; ii < subscribers.size(); ii++)
1879 {
1880 MockTopicSubscriber currentSubscriber = (MockTopicSubscriber)subscribers.get(ii);
1881 if(!currentSubscriber.isClosed())
1882 {
1883 throw new VerifyFailedException("TopicSubscriber with index " + ii + " not closed.");
1884 }
1885 }
1886 }
1887
1888 /**
1889 * Verifies the number of browsers for the specified session.
1890 * The session has to be created using the current {@link MockQueueConnection}.
1891 * @param indexOfSession the index of the session
1892 * @param numberOfBrowsers the expected number of browsers
1893 * @throws VerifyFailedException if verification fails
1894 */
1895 public void verifyNumberQueueBrowsers(int indexOfSession, int numberOfBrowsers)
1896 {
1897 checkAndGetQueueSessionByIndex(indexOfSession);
1898 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1899 if(numberOfBrowsers != manager.getQueueBrowserList().size())
1900 {
1901 throw new VerifyFailedException("Expected " + numberOfBrowsers + " browsers, actually " + manager.getQueueBrowserList().size() + " browsers present");
1902 }
1903 }
1904
1905 /**
1906 * Verifies the number of browsers for the specified session and
1907 * the specified queue name.
1908 * The session has to be created using the current {@link MockQueueConnection}.
1909 * @param indexOfSession the index of the session
1910 * @param queueName the name of the queue
1911 * @param numberOfBrowsers the expected number of browsers
1912 * @throws VerifyFailedException if verification fails
1913 */
1914 public void verifyNumberQueueBrowsers(int indexOfSession, String queueName, int numberOfBrowsers)
1915 {
1916 checkAndGetQueueSessionByIndex(indexOfSession);
1917 checkQueueByName(queueName);
1918 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1919 if(numberOfBrowsers != manager.getQueueBrowserList(queueName).size())
1920 {
1921 throw new VerifyFailedException("Expected " + numberOfBrowsers + " browsers for queue " + queueName + ", actually " + manager.getQueueBrowserList(queueName).size() + " browsers present");
1922 }
1923 }
1924
1925 /**
1926 * Verifies that the specified browser is closed.
1927 * The session has to be created using the current {@link MockQueueConnection}.
1928 * @param indexOfSession the index of the session
1929 * @param queueName the name of the queue
1930 * @param indexOfBrowser the index of the browser
1931 * @throws VerifyFailedException if verification fails
1932 */
1933 public void verifyQueueBrowserClosed(int indexOfSession, String queueName, int indexOfBrowser)
1934 {
1935 checkAndGetQueueSessionByIndex(indexOfSession);
1936 checkQueueByName(queueName);
1937 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1938 List browsers = manager.getQueueBrowserList(queueName);
1939 if(indexOfBrowser >= browsers.size())
1940 {
1941 throw new VerifyFailedException("QueueBrowser with index " + indexOfBrowser + " is not present.");
1942 }
1943 MockQueueBrowser browser = (MockQueueBrowser)browsers.get(indexOfBrowser);
1944 if(!browser.isClosed())
1945 {
1946 throw new VerifyFailedException("QueueBrowser of queue " + queueName + " with index " + indexOfBrowser + " not closed.");
1947 }
1948 }
1949
1950 /**
1951 * Verifies that all browsers for the specified session are closed.
1952 * The session has to be created using the current {@link MockQueueConnection}.
1953 * @param indexOfSession the index of the session
1954 * @throws VerifyFailedException if verification fails
1955 */
1956 public void verifyAllQueueBrowsersClosed(int indexOfSession)
1957 {
1958 checkAndGetQueueSessionByIndex(indexOfSession);
1959 QueueTransmissionManager manager = getQueueTransmissionManager(indexOfSession);
1960 List browsers = manager.getQueueBrowserList();
1961 for(int ii = 0; ii < browsers.size(); ii++)
1962 {
1963 MockQueueBrowser currentBrowser = (MockQueueBrowser)browsers.get(ii);
1964 if(!currentBrowser.isClosed())
1965 {
1966 throw new VerifyFailedException("QueueBrowser with index " + ii + " not closed.");
1967 }
1968 }
1969 }
1970
1971 /**
1972 * Verifies that a durable subscriber exists.
1973 * The session has to be created using the current {@link MockTopicConnection}.
1974 * @param indexOfSession the index of the session
1975 * @param nameOfSubscriber the name of the durable subscriber
1976 * @throws VerifyFailedException if verification fails
1977 */
1978 public void verifyDurableTopicSubscriberPresent(int indexOfSession, String nameOfSubscriber)
1979 {
1980 checkAndGetTopicSessionByIndex(indexOfSession);
1981 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1982 if(null == manager.getDurableTopicSubscriber(nameOfSubscriber))
1983 {
1984 throw new VerifyFailedException("Durable subscriber with name " + nameOfSubscriber + " not present.");
1985 }
1986 }
1987
1988 /**
1989 * Verifies the number of durable subscribers for the specified session.
1990 * The session has to be created using the current {@link MockTopicConnection}.
1991 * @param indexOfSession the index of the session
1992 * @param numberOfSubscribers the expected number of durable subscribers
1993 * @throws VerifyFailedException if verification fails
1994 */
1995 public void verifyNumberDurableTopicSubscribers(int indexOfSession, int numberOfSubscribers)
1996 {
1997 checkAndGetTopicSessionByIndex(indexOfSession);
1998 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
1999 if(numberOfSubscribers != manager.getDurableTopicSubscriberMap().size())
2000 {
2001 throw new VerifyFailedException("Expected " + numberOfSubscribers + " durable subscribers, actually " + manager.getDurableTopicSubscriberMap().size() + " durable subscribers present");
2002 }
2003 }
2004
2005 /**
2006 * Verifies the number of durable subscribers for the specified session and
2007 * the specified topic name.
2008 * The session has to be created using the current {@link MockTopicConnection}.
2009 * @param indexOfSession the index of the session
2010 * @param topicName the name of the topic
2011 * @param numberOfSubscribers the expected number of durable subscribers
2012 * @throws VerifyFailedException if verification fails
2013 */
2014 public void verifyNumberDurableTopicSubscribers(int indexOfSession, String topicName, int numberOfSubscribers)
2015 {
2016 checkAndGetTopicSessionByIndex(indexOfSession);
2017 checkTopicByName(topicName);
2018 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
2019 if(numberOfSubscribers != manager.getDurableTopicSubscriberMap(topicName).size())
2020 {
2021 throw new VerifyFailedException("Expected " + numberOfSubscribers + " durable subscribers for topic " + topicName + ", actually " + manager.getDurableTopicSubscriberMap(topicName).size() + " durable subscribers present");
2022 }
2023 }
2024
2025 /**
2026 * Verifies that the specified durable subscriber is closed.
2027 * The session has to be created using the current {@link MockTopicConnection}.
2028 * @param indexOfSession the index of the session
2029 * @param subscriberName the name of the durable subscriber
2030 * @throws VerifyFailedException if verification fails
2031 */
2032 public void verifyDurableTopicSubscriberClosed(int indexOfSession, String subscriberName)
2033 {
2034 checkAndGetTopicSessionByIndex(indexOfSession);
2035 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
2036 MockTopicSubscriber subscriber = (MockTopicSubscriber)manager.getDurableTopicSubscriber(subscriberName);
2037 if(null == subscriber)
2038 {
2039 throw new VerifyFailedException("Durable TopicSubscriber with name " + subscriberName + " not present.");
2040 }
2041 if(!subscriber.isClosed())
2042 {
2043 throw new VerifyFailedException("Durable TopicSubscriber with name " + subscriberName + " not closed.");
2044 }
2045 }
2046
2047 /**
2048 * Verifies that all durable subscribers for the specified session are closed.
2049 * The session has to be created using the current {@link MockTopicConnection}.
2050 * @param indexOfSession the index of the session
2051 * @throws VerifyFailedException if verification fails
2052 */
2053 public void verifyAllDurableTopicSubscribersClosed(int indexOfSession)
2054 {
2055 checkAndGetTopicSessionByIndex(indexOfSession);
2056 TopicTransmissionManager manager = getTopicTransmissionManager(indexOfSession);
2057 Iterator keys = manager.getDurableTopicSubscriberMap().keySet().iterator();
2058 while(keys.hasNext())
2059 {
2060 MockTopicSubscriber currentSubscriber = (MockTopicSubscriber)manager.getDurableTopicSubscriberMap().get(keys.next());
2061 if(!currentSubscriber.isClosed())
2062 {
2063 throw new VerifyFailedException("Durable TopicSubscriber with name " + currentSubscriber.getName() + " not closed.");
2064 }
2065 }
2066 }
2067
2068 /**
2069 * Verifies the number of queue sessions.
2070 * The sessions have to be created using the current {@link MockQueueConnection}.
2071 * @param number the expected number of queue sessions
2072 * @throws VerifyFailedException if verification fails
2073 */
2074 public void verifyNumberQueueSessions(int number)
2075 {
2076 if(number != getQueueSessionList().size())
2077 {
2078 throw new VerifyFailedException("Expected " + number + " queue sessions, actually " + getQueueSessionList().size() + " sessions present");
2079 }
2080 }
2081
2082 /**
2083 * Verifies the number of topic sessions.
2084 * The sessions have to be created using the current {@link MockTopicConnection}.
2085 * @param number the expected number of topic sessions
2086 * @throws VerifyFailedException if verification fails
2087 */
2088 public void verifyNumberTopicSessions(int number)
2089 {
2090 if(number != getTopicSessionList().size())
2091 {
2092 throw new VerifyFailedException("Expected " + number + " topic sessions, actually " + getTopicSessionList().size() + " sessions present");
2093 }
2094 }
2095
2096 /**
2097 * Verifies the number of sessions.
2098 * The sessions have to be created using the current {@link MockConnection}.
2099 * @param number the expected number of sessions
2100 * @throws VerifyFailedException if verification fails
2101 */
2102 public void verifyNumberSessions(int number)
2103 {
2104 if(number != getSessionList().size())
2105 {
2106 throw new VerifyFailedException("Expected " + number + " sessions, actually " + getSessionList().size() + " sessions present");
2107 }
2108 }
2109
2110 /**
2111 * Verifies the number of temporary queues.
2112 * The session has to be created using the current {@link MockQueueConnection}.
2113 * @param indexOfSession the index of the session
2114 * @param numberQueues the expected number of temporary queues
2115 * @throws VerifyFailedException if verification fails
2116 */
2117 public void verifyNumberTemporaryQueues(int indexOfSession, int numberQueues)
2118 {
2119 checkAndGetQueueSessionByIndex(indexOfSession);
2120 if(numberQueues != getTemporaryQueueList(indexOfSession).size())
2121 {
2122 throw new VerifyFailedException("Expected " + numberQueues + " temporary queues, actually " + getTemporaryQueueList(indexOfSession).size() + " temporary queues present");
2123 }
2124 }
2125
2126 /**
2127 * Verifies the number of temporary topics.
2128 * The session has to be created using the current {@link MockTopicConnection}.
2129 * @param indexOfSession the index of the session
2130 * @param numberTopics the expected number of temporary topics
2131 * @throws VerifyFailedException if verification fails
2132 */
2133 public void verifyNumberTemporaryTopics(int indexOfSession, int numberTopics)
2134 {
2135 checkAndGetTopicSessionByIndex(indexOfSession);
2136 if(numberTopics != getTemporaryTopicList(indexOfSession).size())
2137 {
2138 throw new VerifyFailedException("Expected " + numberTopics + " temporary topics, actually " + getTemporaryTopicList(indexOfSession).size() + " temporary topics present");
2139 }
2140 }
2141
2142 /**
2143 * Verifies that the temporary queue with the specified index
2144 * was deleted.
2145 * The session has to be created using the current {@link MockQueueConnection}.
2146 * @param indexOfSession the index of the session
2147 * @param indexOfQueue the index of the queue
2148 * @throws VerifyFailedException if verification fails
2149 */
2150 public void verifyTemporaryQueueDeleted(int indexOfSession, int indexOfQueue)
2151 {
2152 checkAndGetQueueSessionByIndex(indexOfSession);
2153 MockTemporaryQueue queue = getTemporaryQueue(indexOfSession, indexOfQueue);
2154 if(null == queue)
2155 {
2156 throw new VerifyFailedException("TemporaryQueue with index " + indexOfQueue + " is not present.");
2157 }
2158 if(!queue.isDeleted())
2159 {
2160 throw new VerifyFailedException("TemporaryQueue with index " + indexOfQueue + " not deleted.");
2161 }
2162 }
2163
2164 /**
2165 * Verifies that all temporary queues were deleted.
2166 * The session has to be created using the current {@link MockQueueConnection}.
2167 * @param indexOfSession the index of the session
2168 * @throws VerifyFailedException if verification fails
2169 */
2170 public void verifyAllTemporaryQueuesDeleted(int indexOfSession)
2171 {
2172 checkAndGetQueueSessionByIndex(indexOfSession);
2173 List queueList = getTemporaryQueueList(indexOfSession);
2174 for(int ii = 0; ii < queueList.size(); ii++)
2175 {
2176 MockTemporaryQueue currentQueue = (MockTemporaryQueue)queueList.get(ii);
2177 if(!currentQueue.isDeleted())
2178 {
2179 throw new VerifyFailedException("TemporaryQueue with index " + ii + " not deleted.");
2180 }
2181 }
2182 }
2183
2184 /**
2185 * Verifies that the temporary topic with the specified index
2186 * was closed.
2187 * The session has to be created using the current {@link MockTopicConnection}.
2188 * @param indexOfSession the index of the session
2189 * @param indexOfTopic the index of the topic
2190 * @throws VerifyFailedException if verification fails
2191 */
2192 public void verifyTemporaryTopicDeleted(int indexOfSession, int indexOfTopic)
2193 {
2194 checkAndGetTopicSessionByIndex(indexOfSession);
2195 MockTemporaryTopic topic = getTemporaryTopic(indexOfSession, indexOfTopic);
2196 if(null == topic)
2197 {
2198 throw new VerifyFailedException("TemporaryTopic with index " + indexOfTopic + " is not present.");
2199 }
2200 if(!topic.isDeleted())
2201 {
2202 throw new VerifyFailedException("TemporaryTopic with index " + indexOfTopic + " not deleted.");
2203 }
2204 }
2205
2206 /**
2207 * Verifies that all temporary topics were deleted.
2208 * The session has to be created using the current {@link MockTopicConnection}.
2209 * @param indexOfSession the index of the session
2210 * @throws VerifyFailedException if verification fails
2211 */
2212 public void verifyAllTemporaryTopicsDeleted(int indexOfSession)
2213 {
2214 checkAndGetTopicSessionByIndex(indexOfSession);
2215 List topicList = getTemporaryTopicList(indexOfSession);
2216 for(int ii = 0; ii < topicList.size(); ii++)
2217 {
2218 MockTemporaryTopic currentTopic = (MockTemporaryTopic)topicList.get(ii);
2219 if(!currentTopic.isDeleted())
2220 {
2221 throw new VerifyFailedException("TemporaryTopic with index " + ii + " not deleted.");
2222 }
2223 }
2224 }
2225
2226 /**
2227 * Verifies that the specified messages are equal by calling the
2228 * <code>equals()</code> method. All mock messages provide a
2229 * suitable implementation of <code>equals()</code>.
2230 * @param message1 the first message
2231 * @param message2 the second message
2232 * @throws VerifyFailedException if verification fails
2233 */
2234 public void verifyMessageEquals(MockMessage message1, MockMessage message2)
2235 {
2236 if(null == message1)
2237 {
2238 throw new VerifyFailedException("message1 is null");
2239 }
2240 if(null == message2)
2241 {
2242 throw new VerifyFailedException("message2 is null");
2243 }
2244 if(!message1.equals(message2))
2245 {
2246 throw new VerifyFailedException("messages not equal: message1: " + message1.toString() + ", message2: " + message2.toString());
2247 }
2248 }
2249
2250 /**
2251 * Verifies that a message in the specified queue is equal to
2252 * the specified message by calling the <code>equals()</code> method.
2253 * All mock messages provide a suitable implementation of <code>equals()</code>.
2254 * @param nameOfQueue the name of the queue
2255 * @param indexOfSourceMessage the index of the message in the queue
2256 * @param targetMessage the message that will be used for comparison
2257 * @throws VerifyFailedException if verification fails
2258 */
2259 public void verifyCurrentQueueMessageEquals(String nameOfQueue, int indexOfSourceMessage, MockMessage targetMessage)
2260 {
2261 checkQueueByName(nameOfQueue);
2262 List messageList = getCurrentMessageListFromQueue(nameOfQueue);
2263 if(indexOfSourceMessage >= messageList.size())
2264 {
2265 throw new VerifyFailedException("Queue " + nameOfQueue + " contains only " + messageList.size() + " messages");
2266 }
2267 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
2268 verifyMessageEquals(sourceMessage, targetMessage);
2269 }
2270
2271 /**
2272 * Verifies that a received message is equal to the specified message
2273 * by calling the <code>equals()</code> method.
2274 * All mock messages provide a suitable implementation of <code>equals()</code>.
2275 * @param nameOfQueue the name of the queue
2276 * @param indexOfSourceMessage the index of the received message
2277 * @param targetMessage the message that will be used for comparison
2278 * @throws VerifyFailedException if verification fails
2279 */
2280 public void verifyReceivedQueueMessageEquals(String nameOfQueue, int indexOfSourceMessage, MockMessage targetMessage)
2281 {
2282 checkQueueByName(nameOfQueue);
2283 List messageList = getReceivedMessageListFromQueue(nameOfQueue);
2284 if(indexOfSourceMessage >= messageList.size())
2285 {
2286 throw new VerifyFailedException("Queue " + nameOfQueue + " received only " + messageList.size() + " messages");
2287 }
2288 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
2289 verifyMessageEquals(sourceMessage, targetMessage);
2290 }
2291
2292 /**
2293 * Verifies that a message in the specified temporary queue is equal to
2294 * the specified message by calling the <code>equals()</code> method.
2295 * All mock messages provide a suitable implementation of <code>equals()</code>.
2296 * The session has to be created using the current {@link MockQueueConnection}.
2297 * @param indexOfSession the index of the session
2298 * @param indexOfQueue the index of the temporary queue
2299 * @param indexOfSourceMessage the index of the message in the queue
2300 * @param targetMessage the message that will be used for comparison
2301 * @throws VerifyFailedException if verification fails
2302 */
2303 public void verifyCurrentQueueMessageEquals(int indexOfSession, int indexOfQueue, int indexOfSourceMessage, MockMessage targetMessage)
2304 {
2305 checkAndGetQueueSessionByIndex(indexOfSession);
2306 List messageList = getCurrentMessageListFromTemporaryQueue(indexOfSession, indexOfQueue);
2307 if(null == messageList)
2308 {
2309 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " of session with index " + indexOfSession + " does not exist");
2310 }
2311 if(indexOfSourceMessage >= messageList.size())
2312 {
2313 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " contains only " + messageList.size() + " messages");
2314 }
2315 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
2316 verifyMessageEquals(sourceMessage, targetMessage);
2317 }
2318
2319 /**
2320 * Verifies that a received message is equal to the specified message
2321 * by calling the <code>equals()</code> method.
2322 * All mock messages provide a suitable implementation of <code>equals()</code>.
2323 * The session has to be created using the current {@link MockQueueConnection}.
2324 * @param indexOfSession the index of the session
2325 * @param indexOfQueue the index of the temporary queue
2326 * @param indexOfSourceMessage the index of the received message
2327 * @param targetMessage the message that will be used for comparison
2328 * @throws VerifyFailedException if verification fails
2329 */
2330 public void verifyReceivedQueueMessageEquals(int indexOfSession, int indexOfQueue, int indexOfSourceMessage, MockMessage targetMessage)
2331 {
2332 checkAndGetQueueSessionByIndex(indexOfSession);
2333 List messageList = getReceivedMessageListFromTemporaryQueue(indexOfSession, indexOfQueue);
2334 if(null == messageList)
2335 {
2336 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " of session with index " + indexOfSession + " does not exist");
2337 }
2338 if(indexOfSourceMessage >= messageList.size())
2339 {
2340 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " received only " + messageList.size() + " messages");
2341 }
2342 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
2343 verifyMessageEquals(sourceMessage, targetMessage);
2344 }
2345
2346 /**
2347 * Verifies the number of messages in a queue.
2348 * @param nameOfQueue the name of the queue
2349 * @param numberOfMessages the expected number of messages
2350 * @throws VerifyFailedException if verification fails
2351 */
2352 public void verifyNumberOfCurrentQueueMessages(String nameOfQueue, int numberOfMessages)
2353 {
2354 checkQueueByName(nameOfQueue);
2355 List list = getCurrentMessageListFromQueue(nameOfQueue);
2356 if(numberOfMessages != list.size())
2357 {
2358 throw new VerifyFailedException("Expected " + numberOfMessages + " messages in queue " + nameOfQueue + ", received " + list.size() + " messages");
2359 }
2360 }
2361
2362 /**
2363 * Verifies the number of messages received by a queue.
2364 * @param nameOfQueue the name of the queue
2365 * @param numberOfMessages the expected number of messages
2366 * @throws VerifyFailedException if verification fails
2367 */
2368 public void verifyNumberOfReceivedQueueMessages(String nameOfQueue, int numberOfMessages)
2369 {
2370 checkQueueByName(nameOfQueue);
2371 List list = getReceivedMessageListFromQueue(nameOfQueue);
2372 if(numberOfMessages != list.size())
2373 {
2374 throw new VerifyFailedException("Expected " + numberOfMessages + " messages received by queue " + nameOfQueue + ", received " + list.size() + " messages");
2375 }
2376 }
2377
2378 /**
2379 * Verifies the number of messages in a temporary queue.
2380 * The session has to be created using the current {@link MockQueueConnection}.
2381 * @param indexOfSession the index of the session
2382 * @param indexOfQueue the index of the temporary queue
2383 * @param numberOfMessages the expected number of messages
2384 * @throws VerifyFailedException if verification fails
2385 */
2386 public void verifyNumberOfCurrentQueueMessages(int indexOfSession, int indexOfQueue, int numberOfMessages)
2387 {
2388 checkAndGetQueueSessionByIndex(indexOfSession);
2389 List list = getCurrentMessageListFromTemporaryQueue(indexOfSession, indexOfQueue);
2390 if(null == list)
2391 {
2392 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " of session with index " + indexOfSession + " does not exist");
2393 }
2394 if(numberOfMessages != list.size())
2395 {
2396 throw new VerifyFailedException("Expected " + numberOfMessages + " messages, received " + list.size() + " messages");
2397 }
2398 }
2399
2400 /**
2401 * Verifies the number of messages received by a temporary queue.
2402 * The session has to be created using the current {@link MockQueueConnection}.
2403 * @param indexOfSession the index of the session
2404 * @param indexOfQueue the index of the temporary queue
2405 * @param numberOfMessages the expected number of messages
2406 * @throws VerifyFailedException if verification fails
2407 */
2408 public void verifyNumberOfReceivedQueueMessages(int indexOfSession, int indexOfQueue, int numberOfMessages)
2409 {
2410 checkAndGetQueueSessionByIndex(indexOfSession);
2411 List list = getReceivedMessageListFromTemporaryQueue(indexOfSession, indexOfQueue);
2412 if(null == list)
2413 {
2414 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " of session with index " + indexOfSession + " does not exist");
2415 }
2416 if(numberOfMessages != list.size())
2417 {
2418 throw new VerifyFailedException("Expected " + numberOfMessages + " messages, received " + list.size() + " messages");
2419 }
2420 }
2421
2422 /**
2423 * Verifies that all received messages of the specified queue
2424 * are acknowledged.
2425 * @param nameOfQueue the name of the queue
2426 * @throws VerifyFailedException if verification fails
2427 */
2428 public void verifyAllReceivedQueueMessagesAcknowledged(String nameOfQueue)
2429 {
2430 checkQueueByName(nameOfQueue);
2431 List messageList = getReceivedMessageListFromQueue(nameOfQueue);
2432 for(int ii = 0; ii < messageList.size(); ii++)
2433 {
2434 MockMessage currentMessage = (MockMessage)messageList.get(ii);
2435 if(!currentMessage.isAcknowledged())
2436 {
2437 throw new VerifyFailedException("Message " + ii + " of queue " + nameOfQueue + " is not acknowledged");
2438 }
2439 }
2440 }
2441
2442 /**
2443 * Verifies that all received messages of the specified temporary queue
2444 * are acknowledged.
2445 * The session has to be created using the current {@link MockQueueConnection}.
2446 * @param indexOfSession the index of the session
2447 * @param indexOfQueue the index of the temporary queue
2448 * @throws VerifyFailedException if verification fails
2449 */
2450 public void verifyAllReceivedQueueMessagesAcknowledged(int indexOfSession, int indexOfQueue)
2451 {
2452 checkAndGetQueueSessionByIndex(indexOfSession);
2453 List messageList = getReceivedMessageListFromTemporaryQueue(indexOfSession, indexOfQueue);
2454 if(null == messageList)
2455 {
2456 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " of session with index " + indexOfSession + " does not exist");
2457 }
2458 for(int ii = 0; ii < messageList.size(); ii++)
2459 {
2460 MockMessage currentMessage = (MockMessage)messageList.get(ii);
2461 if(!currentMessage.isAcknowledged())
2462 {
2463 throw new VerifyFailedException("Message " + ii + " of temporary queue " + indexOfQueue + " is not acknowledged");
2464 }
2465 }
2466 }
2467
2468 /**
2469 * Verifies that a received message is acknowledged.
2470 * @param nameOfQueue the name of the queue
2471 * @param indexOfMessage the index of the received message
2472 * @throws VerifyFailedException if verification fails
2473 */
2474 public void verifyReceivedQueueMessageAcknowledged(String nameOfQueue, int indexOfMessage)
2475 {
2476 checkQueueByName(nameOfQueue);
2477 List messageList = getReceivedMessageListFromQueue(nameOfQueue);
2478 if(indexOfMessage >= messageList.size())
2479 {
2480 throw new VerifyFailedException("Queue " + nameOfQueue + " received only " + messageList.size() + " messages");
2481 }
2482 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2483 if(!message.isAcknowledged())
2484 {
2485 throw new VerifyFailedException("Message " + indexOfMessage + " of queue " + nameOfQueue + " is not acknowledged");
2486 }
2487 }
2488
2489 /**
2490 * Verifies that a received message is not acknowledged.
2491 * @param nameOfQueue the name of the queue
2492 * @param indexOfMessage the index of the received message
2493 * @throws VerifyFailedException if verification fails
2494 */
2495 public void verifyReceivedQueueMessageNotAcknowledged(String nameOfQueue, int indexOfMessage)
2496 {
2497 checkQueueByName(nameOfQueue);
2498 List messageList = getReceivedMessageListFromQueue(nameOfQueue);
2499 if(indexOfMessage >= messageList.size())
2500 {
2501 throw new VerifyFailedException("Queue " + nameOfQueue + " received only " + messageList.size() + " messages");
2502 }
2503 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2504 if(message.isAcknowledged())
2505 {
2506 throw new VerifyFailedException("Message " + indexOfMessage + " of queue " + nameOfQueue + " is acknowledged");
2507 }
2508 }
2509
2510 /**
2511 * Verifies that a received message is acknowledged.
2512 * The session has to be created using the current {@link MockQueueConnection}.
2513 * @param indexOfSession the index of the session
2514 * @param indexOfQueue the index of the temporary queue
2515 * @param indexOfMessage the index of the received message
2516 * @throws VerifyFailedException if verification fails
2517 */
2518 public void verifyReceivedQueueMessageAcknowledged(int indexOfSession, int indexOfQueue, int indexOfMessage)
2519 {
2520 checkAndGetQueueSessionByIndex(indexOfSession);
2521 List messageList = getReceivedMessageListFromTemporaryQueue(indexOfSession, indexOfQueue);
2522 if(null == messageList)
2523 {
2524 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " of session with index " + indexOfSession + " does not exist");
2525 }
2526 if(indexOfMessage >= messageList.size())
2527 {
2528 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " received only " + messageList.size() + " messages");
2529 }
2530 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2531 if(!message.isAcknowledged())
2532 {
2533 throw new VerifyFailedException("Message " + indexOfMessage + " of temporary queue " + indexOfQueue + " is not acknowledged");
2534 }
2535 }
2536
2537 /**
2538 * Verifies that a received message is not acknowledged.
2539 * The session has to be created using the current {@link MockQueueConnection}.
2540 * @param indexOfSession the index of the session
2541 * @param indexOfQueue the index of the temporary queue
2542 * @param indexOfMessage the index of the received message
2543 * @throws VerifyFailedException if verification fails
2544 */
2545 public void verifyReceivedQueueMessageNotAcknowledged(int indexOfSession, int indexOfQueue, int indexOfMessage)
2546 {
2547 checkAndGetQueueSessionByIndex(indexOfSession);
2548 List messageList = getReceivedMessageListFromTemporaryQueue(indexOfSession, indexOfQueue);
2549 if(null == messageList)
2550 {
2551 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " of session with index " + indexOfSession + " does not exist");
2552 }
2553 if(indexOfMessage >= messageList.size())
2554 {
2555 throw new VerifyFailedException("Temporary queue with index " + indexOfQueue + " received only " + messageList.size() + " messages");
2556 }
2557 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2558 if(message.isAcknowledged())
2559 {
2560 throw new VerifyFailedException("Message " + indexOfMessage + " of temporary queue " + indexOfQueue + " is acknowledged");
2561 }
2562 }
2563
2564 /**
2565 * Verifies the number of messages created with
2566 * {@link MockQueueSession#createMessage}.
2567 * The session has to be created using the current {@link MockQueueConnection}.
2568 * @param indexOfSession the index of the session
2569 * @param number the expected number of messages
2570 * @throws VerifyFailedException if verification fails
2571 */
2572 public void verifyNumberOfCreatedQueueMessages(int indexOfSession, int number)
2573 {
2574 checkAndGetQueueSessionByIndex(indexOfSession);
2575 if(number != getQueueMessageManager(indexOfSession).getMessageList().size())
2576 {
2577 throw new VerifyFailedException("Expected " + number + " messages, received " + getQueueMessageManager(indexOfSession).getMessageList().size() + " messages");
2578 }
2579 }
2580
2581 /**
2582 * Verifies the number of bytes messages created with
2583 * {@link MockQueueSession#createBytesMessage}.
2584 * The session has to be created using the current {@link MockQueueConnection}.
2585 * @param indexOfSession the index of the session
2586 * @param number the expected number of bytes messages
2587 * @throws VerifyFailedException if verification fails
2588 */
2589 public void verifyNumberOfCreatedQueueBytesMessages(int indexOfSession, int number)
2590 {
2591 checkAndGetQueueSessionByIndex(indexOfSession);
2592 if(number != getQueueMessageManager(indexOfSession).getBytesMessageList().size())
2593 {
2594 throw new VerifyFailedException("Expected " + number + " bytes messages, received " + getQueueMessageManager(indexOfSession).getBytesMessageList().size() + " bytes messages");
2595 }
2596 }
2597
2598 /**
2599 * Verifies the number of map messages created with
2600 * {@link MockQueueSession#createMapMessage}.
2601 * The session has to be created using the current {@link MockQueueConnection}.
2602 * @param indexOfSession the index of the session
2603 * @param number the expected number of map messages
2604 * @throws VerifyFailedException if verification fails
2605 */
2606 public void verifyNumberOfCreatedQueueMapMessages(int indexOfSession, int number)
2607 {
2608 checkAndGetQueueSessionByIndex(indexOfSession);
2609 if(number != getQueueMessageManager(indexOfSession).getMapMessageList().size())
2610 {
2611 throw new VerifyFailedException("Expected " + number + " map messages, received " + getQueueMessageManager(indexOfSession).getMapMessageList().size() + " map messages");
2612 }
2613 }
2614
2615 /**
2616 * Verifies the number of text messages created with
2617 * {@link MockQueueSession#createTextMessage}.
2618 * The session has to be created using the current {@link MockQueueConnection}.
2619 * @param indexOfSession the index of the session
2620 * @param number the expected number of text messages
2621 * @throws VerifyFailedException if verification fails
2622 */
2623 public void verifyNumberOfCreatedQueueTextMessages(int indexOfSession, int number)
2624 {
2625 checkAndGetQueueSessionByIndex(indexOfSession);
2626 if(number != getQueueMessageManager(indexOfSession).getTextMessageList().size())
2627 {
2628 throw new VerifyFailedException("Expected " + number + " text messages, received " + getQueueMessageManager(indexOfSession).getTextMessageList().size() + " text messages");
2629 }
2630 }
2631
2632 /**
2633 * Verifies the number of stream messages created with
2634 * {@link MockQueueSession#createStreamMessage}.
2635 * The session has to be created using the current {@link MockQueueConnection}.
2636 * @param indexOfSession the index of the session
2637 * @param number the expected number of stream messages
2638 * @throws VerifyFailedException if verification fails
2639 */
2640 public void verifyNumberOfCreatedQueueStreamMessages(int indexOfSession, int number)
2641 {
2642 checkAndGetQueueSessionByIndex(indexOfSession);
2643 if(number != getQueueMessageManager(indexOfSession).getStreamMessageList().size())
2644 {
2645 throw new VerifyFailedException("Expected " + number + " stream messages, received " + getQueueMessageManager(indexOfSession).getStreamMessageList().size() + " stream messages");
2646 }
2647 }
2648
2649 /**
2650 * Verifies the number of object messages created with
2651 * {@link MockQueueSession#createObjectMessage}.
2652 * The session has to be created using the current {@link MockQueueConnection}.
2653 * @param indexOfSession the index of the session
2654 * @param number the expected number of object messages
2655 * @throws VerifyFailedException if verification fails
2656 */
2657 public void verifyNumberOfCreatedQueueObjectMessages(int indexOfSession, int number)
2658 {
2659 checkAndGetQueueSessionByIndex(indexOfSession);
2660 if(number != getQueueMessageManager(indexOfSession).getObjectMessageList().size())
2661 {
2662 throw new VerifyFailedException("Expected " + number + " object messages, received " + getQueueMessageManager(indexOfSession).getObjectMessageList().size() + " object messages");
2663 }
2664 }
2665
2666 /**
2667 * Verifies that a message created with {@link MockQueueSession#createMessage}
2668 * is acknowledged.
2669 * The session has to be created using the current {@link MockQueueConnection}.
2670 * @param indexOfSession the index of the session
2671 * @param indexOfMessage the index of the message
2672 * @throws VerifyFailedException if verification fails
2673 */
2674 public void verifyCreatedQueueMessageAcknowledged(int indexOfSession, int indexOfMessage)
2675 {
2676 checkAndGetQueueSessionByIndex(indexOfSession);
2677 List messageList = getQueueMessageManager(indexOfSession).getMessageList();
2678 if(indexOfMessage >= messageList.size())
2679 {
2680 throw new VerifyFailedException("Only " + messageList.size() + " messages created for session " + indexOfSession);
2681 }
2682 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2683 if(!message.isAcknowledged())
2684 {
2685 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
2686 }
2687 }
2688
2689 /**
2690 * Verifies that a message created with {@link MockQueueSession#createMessage}
2691 * is not acknowledged.
2692 * The session has to be created using the current {@link MockQueueConnection}.
2693 * @param indexOfSession the index of the session
2694 * @param indexOfMessage the index of the message
2695 * @throws VerifyFailedException if verification fails
2696 */
2697 public void verifyCreatedQueueMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
2698 {
2699 checkAndGetQueueSessionByIndex(indexOfSession);
2700 List messageList = getQueueMessageManager(indexOfSession).getMessageList();
2701 if(indexOfMessage >= messageList.size())
2702 {
2703 throw new VerifyFailedException("Only " + messageList.size() + " messages created for session " + indexOfSession);
2704 }
2705 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2706 if(message.isAcknowledged())
2707 {
2708 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
2709 }
2710 }
2711
2712 /**
2713 * Verifies that a bytes message created with {@link MockQueueSession#createMessage}
2714 * is acknowledged.
2715 * The session has to be created using the current {@link MockQueueConnection}.
2716 * @param indexOfSession the index of the session
2717 * @param indexOfMessage the index of the message
2718 * @throws VerifyFailedException if verification fails
2719 */
2720 public void verifyCreatedQueueBytesMessageAcknowledged(int indexOfSession, int indexOfMessage)
2721 {
2722 checkAndGetQueueSessionByIndex(indexOfSession);
2723 List messageList = getQueueMessageManager(indexOfSession).getBytesMessageList();
2724 if(indexOfMessage >= messageList.size())
2725 {
2726 throw new VerifyFailedException("Only " + messageList.size() + " bytes messages created for session " + indexOfSession);
2727 }
2728 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2729 if(!message.isAcknowledged())
2730 {
2731 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
2732 }
2733 }
2734
2735 /**
2736 * Verifies that a bytes message created with {@link MockQueueSession#createMessage}
2737 * is not acknowledged.
2738 * The session has to be created using the current {@link MockQueueConnection}.
2739 * @param indexOfSession the index of the session
2740 * @param indexOfMessage the index of the message
2741 * @throws VerifyFailedException if verification fails
2742 */
2743 public void verifyCreatedQueueBytesMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
2744 {
2745 checkAndGetQueueSessionByIndex(indexOfSession);
2746 List messageList = getQueueMessageManager(indexOfSession).getBytesMessageList();
2747 if(indexOfMessage >= messageList.size())
2748 {
2749 throw new VerifyFailedException("Only " + messageList.size() + " bytes messages created for session " + indexOfSession);
2750 }
2751 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2752 if(message.isAcknowledged())
2753 {
2754 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
2755 }
2756 }
2757
2758 /**
2759 * Verifies that a map message created with {@link MockQueueSession#createMessage}
2760 * is acknowledged.
2761 * The session has to be created using the current {@link MockQueueConnection}.
2762 * @param indexOfSession the index of the session
2763 * @param indexOfMessage the index of the message
2764 * @throws VerifyFailedException if verification fails
2765 */
2766 public void verifyCreatedQueueMapMessageAcknowledged(int indexOfSession, int indexOfMessage)
2767 {
2768 checkAndGetQueueSessionByIndex(indexOfSession);
2769 List messageList = getQueueMessageManager(indexOfSession).getMapMessageList();
2770 if(indexOfMessage >= messageList.size())
2771 {
2772 throw new VerifyFailedException("Only " + messageList.size() + " map messages created for session " + indexOfSession);
2773 }
2774 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2775 if(!message.isAcknowledged())
2776 {
2777 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
2778 }
2779 }
2780
2781 /**
2782 * Verifies that a map message created with {@link MockQueueSession#createMessage}
2783 * is not acknowledged.
2784 * The session has to be created using the current {@link MockQueueConnection}.
2785 * @param indexOfSession the index of the session
2786 * @param indexOfMessage the index of the message
2787 * @throws VerifyFailedException if verification fails
2788 */
2789 public void verifyCreatedQueueMapMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
2790 {
2791 checkAndGetQueueSessionByIndex(indexOfSession);
2792 List messageList = getQueueMessageManager(indexOfSession).getMapMessageList();
2793 if(indexOfMessage >= messageList.size())
2794 {
2795 throw new VerifyFailedException("Only " + messageList.size() + " map messages created for session " + indexOfSession);
2796 }
2797 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2798 if(message.isAcknowledged())
2799 {
2800 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
2801 }
2802 }
2803
2804 /**
2805 * Verifies that a text message created with {@link MockQueueSession#createMessage}
2806 * is acknowledged.
2807 * The session has to be created using the current {@link MockQueueConnection}.
2808 * @param indexOfSession the index of the session
2809 * @param indexOfMessage the index of the message
2810 * @throws VerifyFailedException if verification fails
2811 */
2812 public void verifyCreatedQueueTextMessageAcknowledged(int indexOfSession, int indexOfMessage)
2813 {
2814 checkAndGetQueueSessionByIndex(indexOfSession);
2815 List messageList = getQueueMessageManager(indexOfSession).getTextMessageList();
2816 if(indexOfMessage >= messageList.size())
2817 {
2818 throw new VerifyFailedException("Only " + messageList.size() + " text messages created for session " + indexOfSession);
2819 }
2820 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2821 if(!message.isAcknowledged())
2822 {
2823 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
2824 }
2825 }
2826
2827 /**
2828 * Verifies that a text message created with {@link MockQueueSession#createMessage}
2829 * is not acknowledged.
2830 * The session has to be created using the current {@link MockQueueConnection}.
2831 * @param indexOfSession the index of the session
2832 * @param indexOfMessage the index of the message
2833 * @throws VerifyFailedException if verification fails
2834 */
2835 public void verifyCreatedQueueTextMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
2836 {
2837 checkAndGetQueueSessionByIndex(indexOfSession);
2838 List messageList = getQueueMessageManager(indexOfSession).getTextMessageList();
2839 if(indexOfMessage >= messageList.size())
2840 {
2841 throw new VerifyFailedException("Only " + messageList.size() + " text messages created for session " + indexOfSession);
2842 }
2843 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2844 if(message.isAcknowledged())
2845 {
2846 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
2847 }
2848 }
2849
2850 /**
2851 * Verifies that a stream message created with {@link MockQueueSession#createMessage}
2852 * is acknowledged.
2853 * The session has to be created using the current {@link MockQueueConnection}.
2854 * @param indexOfSession the index of the session
2855 * @param indexOfMessage the index of the message
2856 * @throws VerifyFailedException if verification fails
2857 */
2858 public void verifyCreatedQueueStreamMessageAcknowledged(int indexOfSession, int indexOfMessage)
2859 {
2860 checkAndGetQueueSessionByIndex(indexOfSession);
2861 List messageList = getQueueMessageManager(indexOfSession).getStreamMessageList();
2862 if(indexOfMessage >= messageList.size())
2863 {
2864 throw new VerifyFailedException("Only " + messageList.size() + " stream messages created for session " + indexOfSession);
2865 }
2866 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2867 if(!message.isAcknowledged())
2868 {
2869 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
2870 }
2871 }
2872
2873 /**
2874 * Verifies that a stream message created with {@link MockQueueSession#createMessage}
2875 * is not acknowledged.
2876 * The session has to be created using the current {@link MockQueueConnection}.
2877 * @param indexOfSession the index of the session
2878 * @param indexOfMessage the index of the message
2879 * @throws VerifyFailedException if verification fails
2880 */
2881 public void verifyCreatedQueueStreamMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
2882 {
2883 checkAndGetQueueSessionByIndex(indexOfSession);
2884 List messageList = getQueueMessageManager(indexOfSession).getStreamMessageList();
2885 if(indexOfMessage >= messageList.size())
2886 {
2887 throw new VerifyFailedException("Only " + messageList.size() + " stream messages created for session " + indexOfSession);
2888 }
2889 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2890 if(message.isAcknowledged())
2891 {
2892 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
2893 }
2894 }
2895
2896 /**
2897 * Verifies that a object message created with {@link MockQueueSession#createMessage}
2898 * is acknowledged.
2899 * The session has to be created using the current {@link MockQueueConnection}.
2900 * @param indexOfSession the index of the session
2901 * @param indexOfMessage the index of the message
2902 * @throws VerifyFailedException if verification fails
2903 */
2904 public void verifyCreatedQueueObjectMessageAcknowledged(int indexOfSession, int indexOfMessage)
2905 {
2906 checkAndGetQueueSessionByIndex(indexOfSession);
2907 List messageList = getQueueMessageManager(indexOfSession).getObjectMessageList();
2908 if(indexOfMessage >= messageList.size())
2909 {
2910 throw new VerifyFailedException("Only " + messageList.size() + " object messages created for session " + indexOfSession);
2911 }
2912 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2913 if(!message.isAcknowledged())
2914 {
2915 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
2916 }
2917 }
2918
2919 /**
2920 * Verifies that a object message created with {@link MockQueueSession#createMessage}
2921 * is not acknowledged.
2922 * The session has to be created using the current {@link MockQueueConnection}.
2923 * @param indexOfSession the index of the session
2924 * @param indexOfMessage the index of the message
2925 * @throws VerifyFailedException if verification fails
2926 */
2927 public void verifyCreatedQueueObjectMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
2928 {
2929 checkAndGetQueueSessionByIndex(indexOfSession);
2930 List messageList = getQueueMessageManager(indexOfSession).getObjectMessageList();
2931 if(indexOfMessage >= messageList.size())
2932 {
2933 throw new VerifyFailedException("Only " + messageList.size() + " object messages created for session " + indexOfSession);
2934 }
2935 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
2936 if(message.isAcknowledged())
2937 {
2938 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
2939 }
2940 }
2941
2942 /**
2943 * Verifies that a message in the specified topic is equal to
2944 * the specified message by calling the <code>equals()</code> method.
2945 * All mock messages provide a suitable implementation of <code>equals()</code>.
2946 * @param nameOfTopic the name of the topic
2947 * @param indexOfSourceMessage the index of the message in the topic
2948 * @param targetMessage the message that will be used for comparison
2949 * @throws VerifyFailedException if verification fails
2950 */
2951 public void verifyCurrentTopicMessageEquals(String nameOfTopic, int indexOfSourceMessage, MockMessage targetMessage)
2952 {
2953 checkTopicByName(nameOfTopic);
2954 List messageList = getCurrentMessageListFromTopic(nameOfTopic);
2955 if(indexOfSourceMessage >= messageList.size())
2956 {
2957 throw new VerifyFailedException("Topic " + nameOfTopic + " contains only " + messageList.size() + " messages");
2958 }
2959 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
2960 verifyMessageEquals(sourceMessage, targetMessage);
2961 }
2962
2963 /**
2964 * Verifies that a received message is equal to the specified message
2965 * by calling the <code>equals()</code> method.
2966 * All mock messages provide a suitable implementation of <code>equals()</code>.
2967 * @param nameOfTopic the name of the topic
2968 * @param indexOfSourceMessage the index of the received message
2969 * @param targetMessage the message that will be used for comparison
2970 * @throws VerifyFailedException if verification fails
2971 */
2972 public void verifyReceivedTopicMessageEquals(String nameOfTopic, int indexOfSourceMessage, MockMessage targetMessage)
2973 {
2974 checkTopicByName(nameOfTopic);
2975 List messageList = getReceivedMessageListFromTopic(nameOfTopic);
2976 if(indexOfSourceMessage >= messageList.size())
2977 {
2978 throw new VerifyFailedException("Topic " + nameOfTopic + " received only " + messageList.size() + " messages");
2979 }
2980 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
2981 verifyMessageEquals(sourceMessage, targetMessage);
2982 }
2983
2984 /**
2985 * Verifies that a message in the specified temporary topic is equal to
2986 * the specified message by calling the <code>equals()</code> method.
2987 * All mock messages provide a suitable implementation of <code>equals()</code>.
2988 * The session has to be created using the current {@link MockTopicConnection}.
2989 * @param indexOfSession the index of the session
2990 * @param indexOfTopic the index of the temporary topic
2991 * @param indexOfSourceMessage the index of the message in the topic
2992 * @param targetMessage the message that will be used for comparison
2993 * @throws VerifyFailedException if verification fails
2994 */
2995 public void verifyCurrentTopicMessageEquals(int indexOfSession, int indexOfTopic, int indexOfSourceMessage, MockMessage targetMessage)
2996 {
2997 checkAndGetTopicSessionByIndex(indexOfSession);
2998 List messageList = getCurrentMessageListFromTemporaryTopic(indexOfSession, indexOfTopic);
2999 if(null == messageList)
3000 {
3001 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " of session with index " + indexOfSession + " does not exist");
3002 }
3003 if(indexOfSourceMessage >= messageList.size())
3004 {
3005 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " contains only " + messageList.size() + " messages");
3006 }
3007 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
3008 verifyMessageEquals(sourceMessage, targetMessage);
3009 }
3010
3011 /**
3012 * Verifies that a received message is equal to the specified message
3013 * by calling the <code>equals()</code> method.
3014 * All mock messages provide a suitable implementation of <code>equals()</code>.
3015 * The session has to be created using the current {@link MockTopicConnection}.
3016 * @param indexOfSession the index of the session
3017 * @param indexOfTopic the index of the temporary topic
3018 * @param indexOfSourceMessage the index of the received message
3019 * @param targetMessage the message that will be used for comparison
3020 * @throws VerifyFailedException if verification fails
3021 */
3022 public void verifyReceivedTopicMessageEquals(int indexOfSession, int indexOfTopic, int indexOfSourceMessage, MockMessage targetMessage)
3023 {
3024 checkAndGetTopicSessionByIndex(indexOfSession);
3025 List messageList = getReceivedMessageListFromTemporaryTopic(indexOfSession, indexOfTopic);
3026 if(null == messageList)
3027 {
3028 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " of session with index " + indexOfSession + " does not exist");
3029 }
3030 if(indexOfSourceMessage >= messageList.size())
3031 {
3032 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " received only " + messageList.size() + " messages");
3033 }
3034 MockMessage sourceMessage = (MockMessage)messageList.get(indexOfSourceMessage);
3035 verifyMessageEquals(sourceMessage, targetMessage);
3036 }
3037
3038 /**
3039 * Verifies the number of messages in a topic.
3040 * @param nameOfTopic the name of the topic
3041 * @param numberOfMessages the expected number of messages
3042 * @throws VerifyFailedException if verification fails
3043 */
3044 public void verifyNumberOfCurrentTopicMessages(String nameOfTopic, int numberOfMessages)
3045 {
3046 checkTopicByName(nameOfTopic);
3047 List list = getCurrentMessageListFromTopic(nameOfTopic);
3048 if(numberOfMessages != list.size())
3049 {
3050 throw new VerifyFailedException("Expected " + numberOfMessages + " messages in topic " + nameOfTopic + ", received " + list.size() + " messages");
3051 }
3052 }
3053
3054 /**
3055 * Verifies the number of messages received by a topic.
3056 * @param nameOfTopic the name of the topic
3057 * @param numberOfMessages the expected number of messages
3058 * @throws VerifyFailedException if verification fails
3059 */
3060 public void verifyNumberOfReceivedTopicMessages(String nameOfTopic, int numberOfMessages)
3061 {
3062 checkTopicByName(nameOfTopic);
3063 List list = getReceivedMessageListFromTopic(nameOfTopic);
3064 if(numberOfMessages != list.size())
3065 {
3066 throw new VerifyFailedException("Expected " + numberOfMessages + " messages received by topic " + nameOfTopic + ", received " + list.size() + " messages");
3067 }
3068 }
3069
3070 /**
3071 * Verifies the number of messages in a temporary topic.
3072 * The session has to be created using the current {@link MockTopicConnection}.
3073 * @param indexOfSession the index of the session
3074 * @param indexOfTopic the index of the temporary topic
3075 * @param numberOfMessages the expected number of messages
3076 * @throws VerifyFailedException if verification fails
3077 */
3078 public void verifyNumberOfCurrentTopicMessages(int indexOfSession, int indexOfTopic, int numberOfMessages)
3079 {
3080 checkAndGetTopicSessionByIndex(indexOfSession);
3081 List list = getCurrentMessageListFromTemporaryTopic(indexOfSession, indexOfTopic);
3082 if(null == list)
3083 {
3084 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " of session with index " + indexOfSession + " does not exist");
3085 }
3086 if(numberOfMessages != list.size())
3087 {
3088 throw new VerifyFailedException("Expected " + numberOfMessages + " messages, received " + list.size() + " messages");
3089 }
3090 }
3091
3092 /**
3093 * Verifies the number of messages received by a temporary topic.
3094 * The session has to be created using the current {@link MockTopicConnection}.
3095 * @param indexOfSession the index of the session
3096 * @param indexOfTopic the index of the temporary topic
3097 * @param numberOfMessages the expected number of messages
3098 * @throws VerifyFailedException if verification fails
3099 */
3100 public void verifyNumberOfReceivedTopicMessages(int indexOfSession, int indexOfTopic, int numberOfMessages)
3101 {
3102 checkAndGetTopicSessionByIndex(indexOfSession);
3103 List list = getReceivedMessageListFromTemporaryTopic(indexOfSession, indexOfTopic);
3104 if(null == list)
3105 {
3106 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " of session with index " + indexOfSession + " does not exist");
3107 }
3108 if(numberOfMessages != list.size())
3109 {
3110 throw new VerifyFailedException("Expected " + numberOfMessages + " messages, received " + list.size() + " messages");
3111 }
3112 }
3113
3114 /**
3115 * Verifies that all received messages of the specified topic
3116 * are acknowledged.
3117 * @param nameOfTopic the name of the topic
3118 * @throws VerifyFailedException if verification fails
3119 */
3120 public void verifyAllReceivedTopicMessagesAcknowledged(String nameOfTopic)
3121 {
3122 checkTopicByName(nameOfTopic);
3123 List messageList = getReceivedMessageListFromTopic(nameOfTopic);
3124 for(int ii = 0; ii < messageList.size(); ii++)
3125 {
3126 MockMessage currentMessage = (MockMessage)messageList.get(ii);
3127 if(!currentMessage.isAcknowledged())
3128 {
3129 throw new VerifyFailedException("Message " + ii + " of topic " + nameOfTopic + " is not acknowledged");
3130 }
3131 }
3132 }
3133
3134 /**
3135 * Verifies that all received messages of the specified temporary topic
3136 * are acknowledged.
3137 * The session has to be created using the current {@link MockTopicConnection}.
3138 * @param indexOfSession the index of the session
3139 * @param indexOfTopic the index of the temporary topic
3140 * @throws VerifyFailedException if verification fails
3141 */
3142 public void verifyAllReceivedTopicMessagesAcknowledged(int indexOfSession, int indexOfTopic)
3143 {
3144 checkAndGetTopicSessionByIndex(indexOfSession);
3145 List messageList = getReceivedMessageListFromTemporaryTopic(indexOfSession, indexOfTopic);
3146 if(null == messageList)
3147 {
3148 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " of session with index " + indexOfSession + " does not exist");
3149 }
3150 for(int ii = 0; ii < messageList.size(); ii++)
3151 {
3152 MockMessage currentMessage = (MockMessage)messageList.get(ii);
3153 if(!currentMessage.isAcknowledged())
3154 {
3155 throw new VerifyFailedException("Message " + ii + " of temporary topic " + indexOfTopic + " is not acknowledged");
3156 }
3157 }
3158 }
3159
3160 /**
3161 * Verifies that a received message is acknowledged.
3162 * @param nameOfTopic the name of the topic
3163 * @param indexOfMessage the index of the received message
3164 * @throws VerifyFailedException if verification fails
3165 */
3166 public void verifyReceivedTopicMessageAcknowledged(String nameOfTopic, int indexOfMessage)
3167 {
3168 checkTopicByName(nameOfTopic);
3169 List messageList = getReceivedMessageListFromTopic(nameOfTopic);
3170 if(indexOfMessage >= messageList.size())
3171 {
3172 throw new VerifyFailedException("Topic " + nameOfTopic + " received only " + messageList.size() + " messages");
3173 }
3174 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3175 if(!message.isAcknowledged())
3176 {
3177 throw new VerifyFailedException("Message " + indexOfMessage + " of topic " + nameOfTopic + " is not acknowledged");
3178 }
3179 }
3180
3181 /**
3182 * Verifies that a received message is not acknowledged.
3183 * @param nameOfTopic the name of the topic
3184 * @param indexOfMessage the index of the received message
3185 * @throws VerifyFailedException if verification fails
3186 */
3187 public void verifyReceivedTopicMessageNotAcknowledged(String nameOfTopic, int indexOfMessage)
3188 {
3189 checkTopicByName(nameOfTopic);
3190 List messageList = getReceivedMessageListFromTopic(nameOfTopic);
3191 if(indexOfMessage >= messageList.size())
3192 {
3193 throw new VerifyFailedException("Topic " + nameOfTopic + " received only " + messageList.size() + " messages");
3194 }
3195 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3196 if(message.isAcknowledged())
3197 {
3198 throw new VerifyFailedException("Message " + indexOfMessage + " of topic " + nameOfTopic + " is acknowledged");
3199 }
3200 }
3201
3202 /**
3203 * Verifies that a received message is acknowledged.
3204 * The session has to be created using the current {@link MockTopicConnection}.
3205 * @param indexOfSession the index of the session
3206 * @param indexOfTopic the index of the temporary topic
3207 * @param indexOfMessage the index of the received message
3208 * @throws VerifyFailedException if verification fails
3209 */
3210 public void verifyReceivedTopicMessageAcknowledged(int indexOfSession, int indexOfTopic, int indexOfMessage)
3211 {
3212 checkAndGetTopicSessionByIndex(indexOfSession);
3213 List messageList = getReceivedMessageListFromTemporaryTopic(indexOfSession, indexOfTopic);
3214 if(null == messageList)
3215 {
3216 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " of session with index " + indexOfSession + " does not exist");
3217 }
3218 if(indexOfMessage >= messageList.size())
3219 {
3220 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " received only " + messageList.size() + " messages");
3221 }
3222 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3223 if(!message.isAcknowledged())
3224 {
3225 throw new VerifyFailedException("Message " + indexOfMessage + " of temporary topic " + indexOfTopic + " is not acknowledged");
3226 }
3227 }
3228
3229 /**
3230 * Verifies that a received message is not acknowledged.
3231 * The session has to be created using the current {@link MockTopicConnection}.
3232 * @param indexOfSession the index of the session
3233 * @param indexOfTopic the index of the temporary topic
3234 * @param indexOfMessage the index of the received message
3235 * @throws VerifyFailedException if verification fails
3236 */
3237 public void verifyReceivedTopicMessageNotAcknowledged(int indexOfSession, int indexOfTopic, int indexOfMessage)
3238 {
3239 checkAndGetTopicSessionByIndex(indexOfSession);
3240 List messageList = getReceivedMessageListFromTemporaryTopic(indexOfSession, indexOfTopic);
3241 if(null == messageList)
3242 {
3243 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " of session with index " + indexOfSession + " does not exist");
3244 }
3245 if(indexOfMessage >= messageList.size())
3246 {
3247 throw new VerifyFailedException("Temporary topic with index " + indexOfTopic + " received only " + messageList.size() + " messages");
3248 }
3249 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3250 if(message.isAcknowledged())
3251 {
3252 throw new VerifyFailedException("Message " + indexOfMessage + " of temporary topic " + indexOfTopic + " is acknowledged");
3253 }
3254 }
3255
3256 /**
3257 * Verifies the number of messages created with
3258 * {@link MockTopicSession#createMessage}.
3259 * The session has to be created using the current {@link MockTopicConnection}.
3260 * @param indexOfSession the index of the session
3261 * @param number the expected number of messages
3262 * @throws VerifyFailedException if verification fails
3263 */
3264 public void verifyNumberOfCreatedTopicMessages(int indexOfSession, int number)
3265 {
3266 checkAndGetTopicSessionByIndex(indexOfSession);
3267 if(number != getTopicMessageManager(indexOfSession).getMessageList().size())
3268 {
3269 throw new VerifyFailedException("Expected " + number + " messages, received " + getTopicMessageManager(indexOfSession).getMessageList().size() + " messages");
3270 }
3271 }
3272
3273 /**
3274 * Verifies the number of bytes messages created with
3275 * {@link MockTopicSession#createBytesMessage}.
3276 * The session has to be created using the current {@link MockTopicConnection}.
3277 * @param indexOfSession the index of the session
3278 * @param number the expected number of bytes messages
3279 * @throws VerifyFailedException if verification fails
3280 */
3281 public void verifyNumberOfCreatedTopicBytesMessages(int indexOfSession, int number)
3282 {
3283 checkAndGetTopicSessionByIndex(indexOfSession);
3284 if(number != getTopicMessageManager(indexOfSession).getBytesMessageList().size())
3285 {
3286 throw new VerifyFailedException("Expected " + number + " bytes messages, received " + getTopicMessageManager(indexOfSession).getBytesMessageList().size() + " bytes messages");
3287 }
3288 }
3289
3290 /**
3291 * Verifies the number of map messages created with
3292 * {@link MockTopicSession#createMapMessage}.
3293 * The session has to be created using the current {@link MockTopicConnection}.
3294 * @param indexOfSession the index of the session
3295 * @param number the expected number of map messages
3296 * @throws VerifyFailedException if verification fails
3297 */
3298 public void verifyNumberOfCreatedTopicMapMessages(int indexOfSession, int number)
3299 {
3300 checkAndGetTopicSessionByIndex(indexOfSession);
3301 if(number != getTopicMessageManager(indexOfSession).getMapMessageList().size())
3302 {
3303 throw new VerifyFailedException("Expected " + number + " map messages, received " + getTopicMessageManager(indexOfSession).getMapMessageList().size() + " map messages");
3304 }
3305 }
3306
3307 /**
3308 * Verifies the number of text messages created with
3309 * {@link MockTopicSession#createTextMessage}.
3310 * The session has to be created using the current {@link MockTopicConnection}.
3311 * @param indexOfSession the index of the session
3312 * @param number the expected number of text messages
3313 * @throws VerifyFailedException if verification fails
3314 */
3315 public void verifyNumberOfCreatedTopicTextMessages(int indexOfSession, int number)
3316 {
3317 checkAndGetTopicSessionByIndex(indexOfSession);
3318 if(number != getTopicMessageManager(indexOfSession).getTextMessageList().size())
3319 {
3320 throw new VerifyFailedException("Expected " + number + " text messages, received " + getTopicMessageManager(indexOfSession).getTextMessageList().size() + " text messages");
3321 }
3322 }
3323
3324 /**
3325 * Verifies the number of stream messages created with
3326 * {@link MockTopicSession#createStreamMessage}.
3327 * The session has to be created using the current {@link MockTopicConnection}.
3328 * @param indexOfSession the index of the session
3329 * @param number the expected number of stream messages
3330 * @throws VerifyFailedException if verification fails
3331 */
3332 public void verifyNumberOfCreatedTopicStreamMessages(int indexOfSession, int number)
3333 {
3334 checkAndGetTopicSessionByIndex(indexOfSession);
3335 if(number != getTopicMessageManager(indexOfSession).getStreamMessageList().size())
3336 {
3337 throw new VerifyFailedException("Expected " + number + " stream messages, received " + getTopicMessageManager(indexOfSession).getStreamMessageList().size() + " stream messages");
3338 }
3339 }
3340
3341 /**
3342 * Verifies the number of object messages created with
3343 * {@link MockTopicSession#createObjectMessage}.
3344 * The session has to be created using the current {@link MockTopicConnection}.
3345 * @param indexOfSession the index of the session
3346 * @param number the expected number of object messages
3347 * @throws VerifyFailedException if verification fails
3348 */
3349 public void verifyNumberOfCreatedTopicObjectMessages(int indexOfSession, int number)
3350 {
3351 checkAndGetTopicSessionByIndex(indexOfSession);
3352 if(number != getTopicMessageManager(indexOfSession).getObjectMessageList().size())
3353 {
3354 throw new VerifyFailedException("Expected " + number + " object messages, received " + getTopicMessageManager(indexOfSession).getObjectMessageList().size() + " object messages");
3355 }
3356 }
3357
3358 /**
3359 * Verifies that a message created with {@link MockTopicSession#createMessage}
3360 * is acknowledged.
3361 * The session has to be created using the current {@link MockTopicConnection}.
3362 * @param indexOfSession the index of the session
3363 * @param indexOfMessage the index of the message
3364 * @throws VerifyFailedException if verification fails
3365 */
3366 public void verifyCreatedTopicMessageAcknowledged(int indexOfSession, int indexOfMessage)
3367 {
3368 checkAndGetTopicSessionByIndex(indexOfSession);
3369 List messageList = getTopicMessageManager(indexOfSession).getMessageList();
3370 if(indexOfMessage >= messageList.size())
3371 {
3372 throw new VerifyFailedException("Only " + messageList.size() + " messages created for session " + indexOfSession);
3373 }
3374 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3375 if(!message.isAcknowledged())
3376 {
3377 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3378 }
3379 }
3380
3381 /**
3382 * Verifies that a message created with {@link MockTopicSession#createMessage}
3383 * is not acknowledged.
3384 * The session has to be created using the current {@link MockTopicConnection}.
3385 * @param indexOfSession the index of the session
3386 * @param indexOfMessage the index of the message
3387 * @throws VerifyFailedException if verification fails
3388 */
3389 public void verifyCreatedTopicMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3390 {
3391 checkAndGetTopicSessionByIndex(indexOfSession);
3392 List messageList = getTopicMessageManager(indexOfSession).getMessageList();
3393 if(indexOfMessage >= messageList.size())
3394 {
3395 throw new VerifyFailedException("Only " + messageList.size() + " messages created for session " + indexOfSession);
3396 }
3397 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3398 if(message.isAcknowledged())
3399 {
3400 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3401 }
3402 }
3403
3404 /**
3405 * Verifies that a bytes message created with {@link MockTopicSession#createMessage}
3406 * is acknowledged.
3407 * The session has to be created using the current {@link MockTopicConnection}.
3408 * @param indexOfSession the index of the session
3409 * @param indexOfMessage the index of the message
3410 * @throws VerifyFailedException if verification fails
3411 */
3412 public void verifyCreatedTopicBytesMessageAcknowledged(int indexOfSession, int indexOfMessage)
3413 {
3414 checkAndGetTopicSessionByIndex(indexOfSession);
3415 List messageList = getTopicMessageManager(indexOfSession).getBytesMessageList();
3416 if(indexOfMessage >= messageList.size())
3417 {
3418 throw new VerifyFailedException("Only " + messageList.size() + " bytes messages created for session " + indexOfSession);
3419 }
3420 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3421 if(!message.isAcknowledged())
3422 {
3423 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3424 }
3425 }
3426
3427 /**
3428 * Verifies that a bytes message created with {@link MockTopicSession#createMessage}
3429 * is not acknowledged.
3430 * The session has to be created using the current {@link MockTopicConnection}.
3431 * @param indexOfSession the index of the session
3432 * @param indexOfMessage the index of the message
3433 * @throws VerifyFailedException if verification fails
3434 */
3435 public void verifyCreatedTopicBytesMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3436 {
3437 checkAndGetTopicSessionByIndex(indexOfSession);
3438 List messageList = getTopicMessageManager(indexOfSession).getBytesMessageList();
3439 if(indexOfMessage >= messageList.size())
3440 {
3441 throw new VerifyFailedException("Only " + messageList.size() + " bytes messages created for session " + indexOfSession);
3442 }
3443 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3444 if(message.isAcknowledged())
3445 {
3446 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3447 }
3448 }
3449
3450 /**
3451 * Verifies that a map message created with {@link MockTopicSession#createMessage}
3452 * is acknowledged.
3453 * The session has to be created using the current {@link MockTopicConnection}.
3454 * @param indexOfSession the index of the session
3455 * @param indexOfMessage the index of the message
3456 * @throws VerifyFailedException if verification fails
3457 */
3458 public void verifyCreatedTopicMapMessageAcknowledged(int indexOfSession, int indexOfMessage)
3459 {
3460 checkAndGetTopicSessionByIndex(indexOfSession);
3461 List messageList = getTopicMessageManager(indexOfSession).getMapMessageList();
3462 if(indexOfMessage >= messageList.size())
3463 {
3464 throw new VerifyFailedException("Only " + messageList.size() + " map messages created for session " + indexOfSession);
3465 }
3466 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3467 if(!message.isAcknowledged())
3468 {
3469 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3470 }
3471 }
3472
3473 /**
3474 * Verifies that a map message created with {@link MockTopicSession#createMessage}
3475 * is not acknowledged.
3476 * The session has to be created using the current {@link MockTopicConnection}.
3477 * @param indexOfSession the index of the session
3478 * @param indexOfMessage the index of the message
3479 * @throws VerifyFailedException if verification fails
3480 */
3481 public void verifyCreatedTopicMapMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3482 {
3483 checkAndGetTopicSessionByIndex(indexOfSession);
3484 List messageList = getTopicMessageManager(indexOfSession).getMapMessageList();
3485 if(indexOfMessage >= messageList.size())
3486 {
3487 throw new VerifyFailedException("Only " + messageList.size() + " map messages created for session " + indexOfSession);
3488 }
3489 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3490 if(message.isAcknowledged())
3491 {
3492 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3493 }
3494 }
3495
3496 /**
3497 * Verifies that a text message created with {@link MockTopicSession#createMessage}
3498 * is acknowledged.
3499 * The session has to be created using the current {@link MockTopicConnection}.
3500 * @param indexOfSession the index of the session
3501 * @param indexOfMessage the index of the message
3502 * @throws VerifyFailedException if verification fails
3503 */
3504 public void verifyCreatedTopicTextMessageAcknowledged(int indexOfSession, int indexOfMessage)
3505 {
3506 checkAndGetTopicSessionByIndex(indexOfSession);
3507 List messageList = getTopicMessageManager(indexOfSession).getTextMessageList();
3508 if(indexOfMessage >= messageList.size())
3509 {
3510 throw new VerifyFailedException("Only " + messageList.size() + " text messages created for session " + indexOfSession);
3511 }
3512 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3513 if(!message.isAcknowledged())
3514 {
3515 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3516 }
3517 }
3518
3519 /**
3520 * Verifies that a text message created with {@link MockTopicSession#createMessage}
3521 * is not acknowledged.
3522 * The session has to be created using the current {@link MockTopicConnection}.
3523 * @param indexOfSession the index of the session
3524 * @param indexOfMessage the index of the message
3525 * @throws VerifyFailedException if verification fails
3526 */
3527 public void verifyCreatedTopicTextMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3528 {
3529 checkAndGetTopicSessionByIndex(indexOfSession);
3530 List messageList = getTopicMessageManager(indexOfSession).getTextMessageList();
3531 if(indexOfMessage >= messageList.size())
3532 {
3533 throw new VerifyFailedException("Only " + messageList.size() + " text messages created for session " + indexOfSession);
3534 }
3535 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3536 if(message.isAcknowledged())
3537 {
3538 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3539 }
3540 }
3541
3542 /**
3543 * Verifies that a stream message created with {@link MockTopicSession#createMessage}
3544 * is acknowledged.
3545 * The session has to be created using the current {@link MockTopicConnection}.
3546 * @param indexOfSession the index of the session
3547 * @param indexOfMessage the index of the message
3548 * @throws VerifyFailedException if verification fails
3549 */
3550 public void verifyCreatedTopicStreamMessageAcknowledged(int indexOfSession, int indexOfMessage)
3551 {
3552 checkAndGetTopicSessionByIndex(indexOfSession);
3553 List messageList = getTopicMessageManager(indexOfSession).getStreamMessageList();
3554 if(indexOfMessage >= messageList.size())
3555 {
3556 throw new VerifyFailedException("Only " + messageList.size() + " stream messages created for session " + indexOfSession);
3557 }
3558 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3559 if(!message.isAcknowledged())
3560 {
3561 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3562 }
3563 }
3564
3565 /**
3566 * Verifies that a stream message created with {@link MockTopicSession#createMessage}
3567 * is not acknowledged.
3568 * The session has to be created using the current {@link MockTopicConnection}.
3569 * @param indexOfSession the index of the session
3570 * @param indexOfMessage the index of the message
3571 * @throws VerifyFailedException if verification fails
3572 */
3573 public void verifyCreatedTopicStreamMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3574 {
3575 checkAndGetTopicSessionByIndex(indexOfSession);
3576 List messageList = getTopicMessageManager(indexOfSession).getStreamMessageList();
3577 if(indexOfMessage >= messageList.size())
3578 {
3579 throw new VerifyFailedException("Only " + messageList.size() + " stream messages created for session " + indexOfSession);
3580 }
3581 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3582 if(message.isAcknowledged())
3583 {
3584 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3585 }
3586 }
3587
3588 /**
3589 * Verifies that a object message created with {@link MockTopicSession#createMessage}
3590 * is acknowledged.
3591 * The session has to be created using the current {@link MockTopicConnection}.
3592 * @param indexOfSession the index of the session
3593 * @param indexOfMessage the index of the message
3594 * @throws VerifyFailedException if verification fails
3595 */
3596 public void verifyCreatedTopicObjectMessageAcknowledged(int indexOfSession, int indexOfMessage)
3597 {
3598 checkAndGetTopicSessionByIndex(indexOfSession);
3599 List messageList = getTopicMessageManager(indexOfSession).getObjectMessageList();
3600 if(indexOfMessage >= messageList.size())
3601 {
3602 throw new VerifyFailedException("Only " + messageList.size() + " object messages created for session " + indexOfSession);
3603 }
3604 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3605 if(!message.isAcknowledged())
3606 {
3607 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3608 }
3609 }
3610
3611 /**
3612 * Verifies that a object message created with {@link MockTopicSession#createMessage}
3613 * is not acknowledged.
3614 * The session has to be created using the current {@link MockTopicConnection}.
3615 * @param indexOfSession the index of the session
3616 * @param indexOfMessage the index of the message
3617 * @throws VerifyFailedException if verification fails
3618 */
3619 public void verifyCreatedTopicObjectMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3620 {
3621 checkAndGetTopicSessionByIndex(indexOfSession);
3622 List messageList = getTopicMessageManager(indexOfSession).getObjectMessageList();
3623 if(indexOfMessage >= messageList.size())
3624 {
3625 throw new VerifyFailedException("Only " + messageList.size() + " object messages created for session " + indexOfSession);
3626 }
3627 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3628 if(message.isAcknowledged())
3629 {
3630 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3631 }
3632 }
3633
3634 /**
3635 * Verifies the number of messages created with
3636 * {@link MockSession#createMessage}.
3637 * The session has to be created using the current {@link MockConnection}.
3638 * @param indexOfSession the index of the session
3639 * @param number the expected number of messages
3640 * @throws VerifyFailedException if verification fails
3641 */
3642 public void verifyNumberOfCreatedMessages(int indexOfSession, int number)
3643 {
3644 checkAndGetSessionByIndex(indexOfSession);
3645 if(number != getMessageManager(indexOfSession).getMessageList().size())
3646 {
3647 throw new VerifyFailedException("Expected " + number + " messages, received " + getMessageManager(indexOfSession).getMessageList().size() + " messages");
3648 }
3649 }
3650
3651 /**
3652 * Verifies the number of bytes messages created with
3653 * {@link MockSession#createBytesMessage}.
3654 * The session has to be created using the current {@link MockConnection}.
3655 * @param indexOfSession the index of the session
3656 * @param number the expected number of bytes messages
3657 * @throws VerifyFailedException if verification fails
3658 */
3659 public void verifyNumberOfCreatedBytesMessages(int indexOfSession, int number)
3660 {
3661 checkAndGetSessionByIndex(indexOfSession);
3662 if(number != getMessageManager(indexOfSession).getBytesMessageList().size())
3663 {
3664 throw new VerifyFailedException("Expected " + number + " bytes messages, received " + getMessageManager(indexOfSession).getBytesMessageList().size() + " bytes messages");
3665 }
3666 }
3667
3668 /**
3669 * Verifies the number of map messages created with
3670 * {@link MockSession#createMapMessage}.
3671 * The session has to be created using the current {@link MockConnection}.
3672 * @param indexOfSession the index of the session
3673 * @param number the expected number of map messages
3674 * @throws VerifyFailedException if verification fails
3675 */
3676 public void verifyNumberOfCreatedMapMessages(int indexOfSession, int number)
3677 {
3678 checkAndGetSessionByIndex(indexOfSession);
3679 if(number != getMessageManager(indexOfSession).getMapMessageList().size())
3680 {
3681 throw new VerifyFailedException("Expected " + number + " map messages, received " + getMessageManager(indexOfSession).getMapMessageList().size() + " map messages");
3682 }
3683 }
3684
3685 /**
3686 * Verifies the number of text messages created with
3687 * {@link MockSession#createTextMessage}.
3688 * The session has to be created using the current {@link MockConnection}.
3689 * @param indexOfSession the index of the session
3690 * @param number the expected number of text messages
3691 * @throws VerifyFailedException if verification fails
3692 */
3693 public void verifyNumberOfCreatedTextMessages(int indexOfSession, int number)
3694 {
3695 checkAndGetSessionByIndex(indexOfSession);
3696 if(number != getMessageManager(indexOfSession).getTextMessageList().size())
3697 {
3698 throw new VerifyFailedException("Expected " + number + " text messages, received " + getMessageManager(indexOfSession).getTextMessageList().size() + " text messages");
3699 }
3700 }
3701
3702 /**
3703 * Verifies the number of stream messages created with
3704 * {@link MockSession#createStreamMessage}.
3705 * The session has to be created using the current {@link MockConnection}.
3706 * @param indexOfSession the index of the session
3707 * @param number the expected number of stream messages
3708 * @throws VerifyFailedException if verification fails
3709 */
3710 public void verifyNumberOfCreatedStreamMessages(int indexOfSession, int number)
3711 {
3712 checkAndGetSessionByIndex(indexOfSession);
3713 if(number != getMessageManager(indexOfSession).getStreamMessageList().size())
3714 {
3715 throw new VerifyFailedException("Expected " + number + " stream messages, received " + getMessageManager(indexOfSession).getStreamMessageList().size() + " stream messages");
3716 }
3717 }
3718
3719 /**
3720 * Verifies the number of object messages created with
3721 * {@link MockSession#createObjectMessage}.
3722 * The session has to be created using the current {@link MockConnection}.
3723 * @param indexOfSession the index of the session
3724 * @param number the expected number of object messages
3725 * @throws VerifyFailedException if verification fails
3726 */
3727 public void verifyNumberOfCreatedObjectMessages(int indexOfSession, int number)
3728 {
3729 checkAndGetSessionByIndex(indexOfSession);
3730 if(number != getMessageManager(indexOfSession).getObjectMessageList().size())
3731 {
3732 throw new VerifyFailedException("Expected " + number + " object messages, received " + getMessageManager(indexOfSession).getObjectMessageList().size() + " object messages");
3733 }
3734 }
3735
3736 /**
3737 * Verifies that a message created with {@link MockSession#createMessage}
3738 * is acknowledged.
3739 * The session has to be created using the current {@link MockConnection}.
3740 * @param indexOfSession the index of the session
3741 * @param indexOfMessage the index of the message
3742 * @throws VerifyFailedException if verification fails
3743 */
3744 public void verifyCreatedMessageAcknowledged(int indexOfSession, int indexOfMessage)
3745 {
3746 checkAndGetSessionByIndex(indexOfSession);
3747 List messageList = getMessageManager(indexOfSession).getMessageList();
3748 if(indexOfMessage >= messageList.size())
3749 {
3750 throw new VerifyFailedException("Only " + messageList.size() + " messages created for session " + indexOfSession);
3751 }
3752 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3753 if(!message.isAcknowledged())
3754 {
3755 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3756 }
3757 }
3758
3759 /**
3760 * Verifies that a message created with {@link MockSession#createMessage}
3761 * is not acknowledged.
3762 * The session has to be created using the current {@link MockConnection}.
3763 * @param indexOfSession the index of the session
3764 * @param indexOfMessage the index of the message
3765 * @throws VerifyFailedException if verification fails
3766 */
3767 public void verifyCreatedMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3768 {
3769 checkAndGetSessionByIndex(indexOfSession);
3770 List messageList = getMessageManager(indexOfSession).getMessageList();
3771 if(indexOfMessage >= messageList.size())
3772 {
3773 throw new VerifyFailedException("Only " + messageList.size() + " messages created for session " + indexOfSession);
3774 }
3775 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3776 if(message.isAcknowledged())
3777 {
3778 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3779 }
3780 }
3781
3782 /**
3783 * Verifies that a bytes message created with {@link MockSession#createMessage}
3784 * is acknowledged.
3785 * The session has to be created using the current {@link MockConnection}.
3786 * @param indexOfSession the index of the session
3787 * @param indexOfMessage the index of the message
3788 * @throws VerifyFailedException if verification fails
3789 */
3790 public void verifyCreatedBytesMessageAcknowledged(int indexOfSession, int indexOfMessage)
3791 {
3792 checkAndGetSessionByIndex(indexOfSession);
3793 List messageList = getMessageManager(indexOfSession).getBytesMessageList();
3794 if(indexOfMessage >= messageList.size())
3795 {
3796 throw new VerifyFailedException("Only " + messageList.size() + " bytes messages created for session " + indexOfSession);
3797 }
3798 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3799 if(!message.isAcknowledged())
3800 {
3801 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3802 }
3803 }
3804
3805 /**
3806 * Verifies that a bytes message created with {@link MockSession#createMessage}
3807 * is not acknowledged.
3808 * The session has to be created using the current {@link MockConnection}.
3809 * @param indexOfSession the index of the session
3810 * @param indexOfMessage the index of the message
3811 * @throws VerifyFailedException if verification fails
3812 */
3813 public void verifyCreatedBytesMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3814 {
3815 checkAndGetSessionByIndex(indexOfSession);
3816 List messageList = getMessageManager(indexOfSession).getBytesMessageList();
3817 if(indexOfMessage >= messageList.size())
3818 {
3819 throw new VerifyFailedException("Only " + messageList.size() + " bytes messages created for session " + indexOfSession);
3820 }
3821 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3822 if(message.isAcknowledged())
3823 {
3824 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3825 }
3826 }
3827
3828 /**
3829 * Verifies that a map message created with {@link MockSession#createMessage}
3830 * is acknowledged.
3831 * The session has to be created using the current {@link MockConnection}.
3832 * @param indexOfSession the index of the session
3833 * @param indexOfMessage the index of the message
3834 * @throws VerifyFailedException if verification fails
3835 */
3836 public void verifyCreatedMapMessageAcknowledged(int indexOfSession, int indexOfMessage)
3837 {
3838 checkAndGetSessionByIndex(indexOfSession);
3839 List messageList = getMessageManager(indexOfSession).getMapMessageList();
3840 if(indexOfMessage >= messageList.size())
3841 {
3842 throw new VerifyFailedException("Only " + messageList.size() + " map messages created for session " + indexOfSession);
3843 }
3844 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3845 if(!message.isAcknowledged())
3846 {
3847 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3848 }
3849 }
3850
3851 /**
3852 * Verifies that a map message created with {@link MockSession#createMessage}
3853 * is not acknowledged.
3854 * The session has to be created using the current {@link MockConnection}.
3855 * @param indexOfSession the index of the session
3856 * @param indexOfMessage the index of the message
3857 * @throws VerifyFailedException if verification fails
3858 */
3859 public void verifyCreatedMapMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3860 {
3861 checkAndGetSessionByIndex(indexOfSession);
3862 List messageList = getMessageManager(indexOfSession).getMapMessageList();
3863 if(indexOfMessage >= messageList.size())
3864 {
3865 throw new VerifyFailedException("Only " + messageList.size() + " map messages created for session " + indexOfSession);
3866 }
3867 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3868 if(message.isAcknowledged())
3869 {
3870 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3871 }
3872 }
3873
3874 /**
3875 * Verifies that a text message created with {@link MockSession#createMessage}
3876 * is acknowledged.
3877 * The session has to be created using the current {@link MockConnection}.
3878 * @param indexOfSession the index of the session
3879 * @param indexOfMessage the index of the message
3880 * @throws VerifyFailedException if verification fails
3881 */
3882 public void verifyCreatedTextMessageAcknowledged(int indexOfSession, int indexOfMessage)
3883 {
3884 checkAndGetSessionByIndex(indexOfSession);
3885 List messageList = getMessageManager(indexOfSession).getTextMessageList();
3886 if(indexOfMessage >= messageList.size())
3887 {
3888 throw new VerifyFailedException("Only " + messageList.size() + " text messages created for session " + indexOfSession);
3889 }
3890 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3891 if(!message.isAcknowledged())
3892 {
3893 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3894 }
3895 }
3896
3897 /**
3898 * Verifies that a text message created with {@link MockSession#createMessage}
3899 * is not acknowledged.
3900 * The session has to be created using the current {@link MockConnection}.
3901 * @param indexOfSession the index of the session
3902 * @param indexOfMessage the index of the message
3903 * @throws VerifyFailedException if verification fails
3904 */
3905 public void verifyCreatedTextMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3906 {
3907 checkAndGetSessionByIndex(indexOfSession);
3908 List messageList = getMessageManager(indexOfSession).getTextMessageList();
3909 if(indexOfMessage >= messageList.size())
3910 {
3911 throw new VerifyFailedException("Only " + messageList.size() + " text messages created for session " + indexOfSession);
3912 }
3913 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3914 if(message.isAcknowledged())
3915 {
3916 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3917 }
3918 }
3919
3920 /**
3921 * Verifies that a stream message created with {@link MockSession#createMessage}
3922 * is acknowledged.
3923 * The session has to be created using the current {@link MockConnection}.
3924 * @param indexOfSession the index of the session
3925 * @param indexOfMessage the index of the message
3926 * @throws VerifyFailedException if verification fails
3927 */
3928 public void verifyCreatedStreamMessageAcknowledged(int indexOfSession, int indexOfMessage)
3929 {
3930 checkAndGetSessionByIndex(indexOfSession);
3931 List messageList = getMessageManager(indexOfSession).getStreamMessageList();
3932 if(indexOfMessage >= messageList.size())
3933 {
3934 throw new VerifyFailedException("Only " + messageList.size() + " stream messages created for session " + indexOfSession);
3935 }
3936 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3937 if(!message.isAcknowledged())
3938 {
3939 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3940 }
3941 }
3942
3943 /**
3944 * Verifies that a stream message created with {@link MockSession#createMessage}
3945 * is not acknowledged.
3946 * The session has to be created using the current {@link MockConnection}.
3947 * @param indexOfSession the index of the session
3948 * @param indexOfMessage the index of the message
3949 * @throws VerifyFailedException if verification fails
3950 */
3951 public void verifyCreatedStreamMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3952 {
3953 checkAndGetSessionByIndex(indexOfSession);
3954 List messageList = getMessageManager(indexOfSession).getStreamMessageList();
3955 if(indexOfMessage >= messageList.size())
3956 {
3957 throw new VerifyFailedException("Only " + messageList.size() + " stream messages created for session " + indexOfSession);
3958 }
3959 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3960 if(message.isAcknowledged())
3961 {
3962 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
3963 }
3964 }
3965
3966 /**
3967 * Verifies that a object message created with {@link MockSession#createMessage}
3968 * is acknowledged.
3969 * The session has to be created using the current {@link MockConnection}.
3970 * @param indexOfSession the index of the session
3971 * @param indexOfMessage the index of the message
3972 * @throws VerifyFailedException if verification fails
3973 */
3974 public void verifyCreatedObjectMessageAcknowledged(int indexOfSession, int indexOfMessage)
3975 {
3976 checkAndGetSessionByIndex(indexOfSession);
3977 List messageList = getMessageManager(indexOfSession).getObjectMessageList();
3978 if(indexOfMessage >= messageList.size())
3979 {
3980 throw new VerifyFailedException("Only " + messageList.size() + " object messages created for session " + indexOfSession);
3981 }
3982 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
3983 if(!message.isAcknowledged())
3984 {
3985 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is not acknowledged");
3986 }
3987 }
3988
3989 /**
3990 * Verifies that a object message created with {@link MockSession#createMessage}
3991 * is not acknowledged.
3992 * The session has to be created using the current {@link MockConnection}.
3993 * @param indexOfSession the index of the session
3994 * @param indexOfMessage the index of the message
3995 * @throws VerifyFailedException if verification fails
3996 */
3997 public void verifyCreatedObjectMessageNotAcknowledged(int indexOfSession, int indexOfMessage)
3998 {
3999 checkAndGetSessionByIndex(indexOfSession);
4000 List messageList = getMessageManager(indexOfSession).getObjectMessageList();
4001 if(indexOfMessage >= messageList.size())
4002 {
4003 throw new VerifyFailedException("Only " + messageList.size() + " object messages created for session " + indexOfSession);
4004 }
4005 MockMessage message = (MockMessage)messageList.get(indexOfMessage);
4006 if(message.isAcknowledged())
4007 {
4008 throw new VerifyFailedException("Message " + indexOfMessage + " of session " + indexOfSession + " is acknowledged");
4009 }
4010 }
4011
4012 private MockQueueSession checkAndGetQueueSessionByIndex(int indexOfSession)
4013 {
4014 if(null == getCurrentQueueConnection())
4015 {
4016 throw new VerifyFailedException("No QueueConnection present.");
4017 }
4018 MockQueueSession session = getQueueSession(indexOfSession);
4019 if(null == session)
4020 {
4021 throw new VerifyFailedException("QueueSession with index " + indexOfSession + " does not exist.");
4022 }
4023 return session;
4024 }
4025
4026 private MockTopicSession checkAndGetTopicSessionByIndex(int indexOfSession)
4027 {
4028 if(null == getCurrentTopicConnection())
4029 {
4030 throw new VerifyFailedException("No TopicConnection present.");
4031 }
4032 MockTopicSession session = getTopicSession(indexOfSession);
4033 if(null == session)
4034 {
4035 throw new VerifyFailedException("TopicSession with index " + indexOfSession + " does not exist.");
4036 }
4037 return session;
4038 }
4039
4040 private MockSession checkAndGetSessionByIndex(int indexOfSession)
4041 {
4042 if(null == getCurrentConnection())
4043 {
4044 throw new VerifyFailedException("No Connection present.");
4045 }
4046 MockSession session = getSession(indexOfSession);
4047 if(null == session)
4048 {
4049 throw new VerifyFailedException("Session with index " + indexOfSession + " does not exist.");
4050 }
4051 return session;
4052 }
4053
4054 private void checkQueueByName(String queueName)
4055 {
4056 DestinationManager destinationManager = getDestinationManager();
4057 if(null == destinationManager.getQueue(queueName))
4058 {
4059 throw new VerifyFailedException("Queue with name " + queueName + " is not present.");
4060 }
4061 }
4062
4063 private void checkTopicByName(String topicName)
4064 {
4065 DestinationManager destinationManager = getDestinationManager();
4066 if(null == destinationManager.getTopic(topicName))
4067 {
4068 throw new VerifyFailedException("Topic with name " + topicName + " is not present.");
4069 }
4070 }
4071 }