Source Code Cross Referenced for BasicJMSTestCaseAdapter.java in  » Testing » mockrunner-0.4 » com » mockrunner » jms » Java Source Code / Java DocumentationJava Source Code and Java Documentation

Java Source Code / Java Documentation
1. 6.0 JDK Core
2. 6.0 JDK Modules
3. 6.0 JDK Modules com.sun
4. 6.0 JDK Modules com.sun.java
5. 6.0 JDK Modules sun
6. 6.0 JDK Platform
7. Ajax
8. Apache Harmony Java SE
9. Aspect oriented
10. Authentication Authorization
11. Blogger System
12. Build
13. Byte Code
14. Cache
15. Chart
16. Chat
17. Code Analyzer
18. Collaboration
19. Content Management System
20. Database Client
21. Database DBMS
22. Database JDBC Connection Pool
23. Database ORM
24. Development
25. EJB Server geronimo
26. EJB Server GlassFish
27. EJB Server JBoss 4.2.1
28. EJB Server resin 3.1.5
29. ERP CRM Financial
30. ESB
31. Forum
32. GIS
33. Graphic Library
34. Groupware
35. HTML Parser
36. IDE
37. IDE Eclipse
38. IDE Netbeans
39. Installer
40. Internationalization Localization
41. Inversion of Control
42. Issue Tracking
43. J2EE
44. JBoss
45. JMS
46. JMX
47. Library
48. Mail Clients
49. Net
50. Parser
51. PDF
52. Portal
53. Profiler
54. Project Management
55. Report
56. RSS RDF
57. Rule Engine
58. Science
59. Scripting
60. Search Engine
61. Security
62. Sevlet Container
63. Source Control
64. Swing Library
65. Template Engine
66. Test Coverage
67. Testing
68. UML
69. Web Crawler
70. Web Framework
71. Web Mail
72. Web Server
73. Web Services
74. Web Services apache cxf 2.0.1
75. Web Services AXIS2
76. Wiki Engine
77. Workflow Engines
78. XML
79. XML UI
Java
Java Tutorial
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java Source Code / Java Documentation » Testing » mockrunner 0.4 » com.mockrunner.jms 
Source Cross Referenced  Class Diagram Java Document (Java Doc) 


0001:        package com.mockrunner.jms;
0002:
0003:        import java.util.List;
0004:
0005:        import javax.jms.MessageListener;
0006:
0007:        import junit.framework.TestCase;
0008:
0009:        import com.mockrunner.mock.jms.JMSMockObjectFactory;
0010:        import com.mockrunner.mock.jms.MockConnection;
0011:        import com.mockrunner.mock.jms.MockMessage;
0012:        import com.mockrunner.mock.jms.MockQueue;
0013:        import com.mockrunner.mock.jms.MockQueueConnection;
0014:        import com.mockrunner.mock.jms.MockQueueSession;
0015:        import com.mockrunner.mock.jms.MockSession;
0016:        import com.mockrunner.mock.jms.MockTemporaryQueue;
0017:        import com.mockrunner.mock.jms.MockTemporaryTopic;
0018:        import com.mockrunner.mock.jms.MockTopic;
0019:        import com.mockrunner.mock.jms.MockTopicConnection;
0020:        import com.mockrunner.mock.jms.MockTopicSession;
0021:
0022:        /**
0023:         * Delegator for {@link com.mockrunner.jms.JMSTestModule}. You can
0024:         * subclass this adapter or use {@link com.mockrunner.jms.JMSTestModule}
0025:         * directly (so your test case can use another base class).
0026:         * This basic adapter can be used if you don't need any other modules. It
0027:         * does not extend {@link com.mockrunner.base.BaseTestCase}. If you want
0028:         * to use several modules in conjunction, consider subclassing
0029:         * {@link com.mockrunner.jms.JMSTestCaseAdapter}.
0030:         * <b>This class is generated from the {@link com.mockrunner.jms.JMSTestModule}
0031:         * and should not be edited directly</b>.
0032:         */
0033:        public abstract class BasicJMSTestCaseAdapter extends TestCase {
0034:            private JMSTestModule jmsTestModule;
0035:            private JMSMockObjectFactory jmsMockObjectFactory;
0036:
0037:            public BasicJMSTestCaseAdapter() {
0038:
0039:            }
0040:
0041:            public BasicJMSTestCaseAdapter(String name) {
0042:                super (name);
0043:            }
0044:
0045:            protected void tearDown() throws Exception {
0046:                super .tearDown();
0047:                jmsTestModule = null;
0048:                jmsMockObjectFactory = null;
0049:            }
0050:
0051:            /**
0052:             * Creates the {@link com.mockrunner.jms.JMSTestModule}. If you
0053:             * overwrite this method, you must call <code>super.setUp()</code>.
0054:             */
0055:            protected void setUp() throws Exception {
0056:                super .setUp();
0057:                jmsTestModule = createJMSTestModule(getJMSMockObjectFactory());
0058:            }
0059:
0060:            /**
0061:             * Creates a {@link com.mockrunner.mock.jms.JMSMockObjectFactory}.
0062:             * @return the created {@link com.mockrunner.mock.jms.JMSMockObjectFactory}
0063:             */
0064:            protected JMSMockObjectFactory createJMSMockObjectFactory() {
0065:                return new JMSMockObjectFactory();
0066:            }
0067:
0068:            /**
0069:             * Gets the {@link com.mockrunner.mock.jms.JMSMockObjectFactory}.
0070:             * @return the {@link com.mockrunner.mock.jms.JMSMockObjectFactory}
0071:             */
0072:            protected JMSMockObjectFactory getJMSMockObjectFactory() {
0073:                synchronized (JMSMockObjectFactory.class) {
0074:                    if (jmsMockObjectFactory == null) {
0075:                        jmsMockObjectFactory = createJMSMockObjectFactory();
0076:                    }
0077:                }
0078:                return jmsMockObjectFactory;
0079:            }
0080:
0081:            /**
0082:             * Sets the {@link com.mockrunner.mock.jms.JMSMockObjectFactory}.
0083:             * @param jmsMockObjectFactory the {@link com.mockrunner.mock.jms.JMSMockObjectFactory}
0084:             */
0085:            protected void setJMSMockObjectFactory(
0086:                    JMSMockObjectFactory jmsMockObjectFactory) {
0087:                this .jmsMockObjectFactory = jmsMockObjectFactory;
0088:            }
0089:
0090:            /**
0091:             * Creates a {@link com.mockrunner.jms.JMSTestModule} based on the current
0092:             * {@link com.mockrunner.mock.jms.JMSMockObjectFactory}.
0093:             * Same as <code>createJMSTestModule(getJMSMockObjectFactory())</code>.
0094:             * @return the created {@link com.mockrunner.jms.JMSTestModule}
0095:             */
0096:            protected JMSTestModule createJMSTestModule() {
0097:                return new JMSTestModule(getJMSMockObjectFactory());
0098:            }
0099:
0100:            /**
0101:             * Creates a {@link com.mockrunner.jms.JMSTestModule} with the specified
0102:             * {@link com.mockrunner.mock.jms.JMSMockObjectFactory}.
0103:             * @return the created {@link com.mockrunner.jms.JMSTestModule}
0104:             */
0105:            protected JMSTestModule createJMSTestModule(
0106:                    JMSMockObjectFactory mockFactory) {
0107:                return new JMSTestModule(mockFactory);
0108:            }
0109:
0110:            /**
0111:             * Gets the {@link com.mockrunner.jms.JMSTestModule}.
0112:             * @return the {@link com.mockrunner.jms.JMSTestModule}
0113:             */
0114:            protected JMSTestModule getJMSTestModule() {
0115:                return jmsTestModule;
0116:            }
0117:
0118:            /**
0119:             * Sets the {@link com.mockrunner.jms.JMSTestModule}.
0120:             * @param jmsTestModule the {@link com.mockrunner.jms.JMSTestModule}
0121:             */
0122:            protected void setJMSTestModule(JMSTestModule jmsTestModule) {
0123:                this .jmsTestModule = jmsTestModule;
0124:            }
0125:
0126:            /**
0127:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getSession(int)}
0128:             */
0129:            protected MockSession getSession(int indexOfSession) {
0130:                return jmsTestModule.getSession(indexOfSession);
0131:            }
0132:
0133:            /**
0134:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyConnectionClosed}
0135:             */
0136:            protected void verifyConnectionClosed() {
0137:                jmsTestModule.verifyConnectionClosed();
0138:            }
0139:
0140:            /**
0141:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#setCurrentQueueConnectionIndex(int)}
0142:             */
0143:            protected void setCurrentQueueConnectionIndex(int connectionIndex) {
0144:                jmsTestModule.setCurrentQueueConnectionIndex(connectionIndex);
0145:            }
0146:
0147:            /**
0148:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getCurrentQueueConnection}
0149:             */
0150:            protected MockQueueConnection getCurrentQueueConnection() {
0151:                return jmsTestModule.getCurrentQueueConnection();
0152:            }
0153:
0154:            /**
0155:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#setCurrentTopicConnectionIndex(int)}
0156:             */
0157:            protected void setCurrentTopicConnectionIndex(int connectionIndex) {
0158:                jmsTestModule.setCurrentTopicConnectionIndex(connectionIndex);
0159:            }
0160:
0161:            /**
0162:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getCurrentTopicConnection}
0163:             */
0164:            protected MockTopicConnection getCurrentTopicConnection() {
0165:                return jmsTestModule.getCurrentTopicConnection();
0166:            }
0167:
0168:            /**
0169:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#setCurrentConnectionIndex(int)}
0170:             */
0171:            protected void setCurrentConnectionIndex(int connectionIndex) {
0172:                jmsTestModule.setCurrentConnectionIndex(connectionIndex);
0173:            }
0174:
0175:            /**
0176:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getCurrentConnection}
0177:             */
0178:            protected MockConnection getCurrentConnection() {
0179:                return jmsTestModule.getCurrentConnection();
0180:            }
0181:
0182:            /**
0183:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForQueue(MockConnection, String, boolean, int, MessageListener)}
0184:             */
0185:            protected void registerTestMessageListenerForQueue(
0186:                    MockConnection connection, String queueName,
0187:                    boolean transacted, int acknowledgeMode,
0188:                    MessageListener listener) {
0189:                jmsTestModule.registerTestMessageListenerForQueue(connection,
0190:                        queueName, transacted, acknowledgeMode, listener);
0191:            }
0192:
0193:            /**
0194:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForQueue(MockConnection, String, boolean, int, String, MessageListener)}
0195:             */
0196:            protected void registerTestMessageListenerForQueue(
0197:                    MockConnection connection, String queueName,
0198:                    boolean transacted, int acknowledgeMode,
0199:                    String messageSelector, MessageListener listener) {
0200:                jmsTestModule.registerTestMessageListenerForQueue(connection,
0201:                        queueName, transacted, acknowledgeMode,
0202:                        messageSelector, listener);
0203:            }
0204:
0205:            /**
0206:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForQueue(String, MessageListener)}
0207:             */
0208:            protected void registerTestMessageListenerForQueue(
0209:                    String queueName, MessageListener listener) {
0210:                jmsTestModule.registerTestMessageListenerForQueue(queueName,
0211:                        listener);
0212:            }
0213:
0214:            /**
0215:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForQueue(MockConnection, String, MessageListener)}
0216:             */
0217:            protected void registerTestMessageListenerForQueue(
0218:                    MockConnection connection, String queueName,
0219:                    MessageListener listener) {
0220:                jmsTestModule.registerTestMessageListenerForQueue(connection,
0221:                        queueName, listener);
0222:            }
0223:
0224:            /**
0225:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getDestinationManager}
0226:             */
0227:            protected DestinationManager getDestinationManager() {
0228:                return jmsTestModule.getDestinationManager();
0229:            }
0230:
0231:            /**
0232:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForTopic(MockConnection, String, boolean, int, String, MessageListener)}
0233:             */
0234:            protected void registerTestMessageListenerForTopic(
0235:                    MockConnection connection, String topicName,
0236:                    boolean transacted, int acknowledgeMode,
0237:                    String messageSelector, MessageListener listener) {
0238:                jmsTestModule.registerTestMessageListenerForTopic(connection,
0239:                        topicName, transacted, acknowledgeMode,
0240:                        messageSelector, listener);
0241:            }
0242:
0243:            /**
0244:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForTopic(MockConnection, String, boolean, int, MessageListener)}
0245:             */
0246:            protected void registerTestMessageListenerForTopic(
0247:                    MockConnection connection, String topicName,
0248:                    boolean transacted, int acknowledgeMode,
0249:                    MessageListener listener) {
0250:                jmsTestModule.registerTestMessageListenerForTopic(connection,
0251:                        topicName, transacted, acknowledgeMode, listener);
0252:            }
0253:
0254:            /**
0255:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForTopic(String, MessageListener)}
0256:             */
0257:            protected void registerTestMessageListenerForTopic(
0258:                    String topicName, MessageListener listener) {
0259:                jmsTestModule.registerTestMessageListenerForTopic(topicName,
0260:                        listener);
0261:            }
0262:
0263:            /**
0264:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#registerTestMessageListenerForTopic(MockConnection, String, MessageListener)}
0265:             */
0266:            protected void registerTestMessageListenerForTopic(
0267:                    MockConnection connection, String topicName,
0268:                    MessageListener listener) {
0269:                jmsTestModule.registerTestMessageListenerForTopic(connection,
0270:                        topicName, listener);
0271:            }
0272:
0273:            /**
0274:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTopic(String)}
0275:             */
0276:            protected MockTopic getTopic(String name) {
0277:                return jmsTestModule.getTopic(name);
0278:            }
0279:
0280:            /**
0281:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getConfigurationManager}
0282:             */
0283:            protected ConfigurationManager getConfigurationManager() {
0284:                return jmsTestModule.getConfigurationManager();
0285:            }
0286:
0287:            /**
0288:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getQueueMessageManager(int)}
0289:             */
0290:            protected MessageManager getQueueMessageManager(int indexOfSession) {
0291:                return jmsTestModule.getQueueMessageManager(indexOfSession);
0292:            }
0293:
0294:            /**
0295:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getQueueSession(int)}
0296:             */
0297:            protected MockQueueSession getQueueSession(int indexOfSession) {
0298:                return jmsTestModule.getQueueSession(indexOfSession);
0299:            }
0300:
0301:            /**
0302:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getMessageManager(int)}
0303:             */
0304:            protected MessageManager getMessageManager(int indexOfSession) {
0305:                return jmsTestModule.getMessageManager(indexOfSession);
0306:            }
0307:
0308:            /**
0309:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTopicMessageManager(int)}
0310:             */
0311:            protected MessageManager getTopicMessageManager(int indexOfSession) {
0312:                return jmsTestModule.getTopicMessageManager(indexOfSession);
0313:            }
0314:
0315:            /**
0316:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTopicSession(int)}
0317:             */
0318:            protected MockTopicSession getTopicSession(int indexOfSession) {
0319:                return jmsTestModule.getTopicSession(indexOfSession);
0320:            }
0321:
0322:            /**
0323:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getQueueTransmissionManager(int)}
0324:             */
0325:            protected QueueTransmissionManager getQueueTransmissionManager(
0326:                    int indexOfSession) {
0327:                return jmsTestModule
0328:                        .getQueueTransmissionManager(indexOfSession);
0329:            }
0330:
0331:            /**
0332:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTopicTransmissionManager(int)}
0333:             */
0334:            protected TopicTransmissionManager getTopicTransmissionManager(
0335:                    int indexOfSession) {
0336:                return jmsTestModule
0337:                        .getTopicTransmissionManager(indexOfSession);
0338:            }
0339:
0340:            /**
0341:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTransmissionManager(int)}
0342:             * @deprecated
0343:             */
0344:            protected TransmissionManagerWrapper getTransmissionManager(
0345:                    int indexOfSession) {
0346:                return jmsTestModule.getTransmissionManager(indexOfSession);
0347:            }
0348:
0349:            /**
0350:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTransmissionManagerWrapper(int)}
0351:             */
0352:            protected TransmissionManagerWrapper getTransmissionManagerWrapper(
0353:                    int indexOfSession) {
0354:                return jmsTestModule
0355:                        .getTransmissionManagerWrapper(indexOfSession);
0356:            }
0357:
0358:            /**
0359:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getQueueTransmissionManagerWrapper(int)}
0360:             */
0361:            protected TransmissionManagerWrapper getQueueTransmissionManagerWrapper(
0362:                    int indexOfSession) {
0363:                return jmsTestModule
0364:                        .getQueueTransmissionManagerWrapper(indexOfSession);
0365:            }
0366:
0367:            /**
0368:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTopicTransmissionManagerWrapper(int)}
0369:             */
0370:            protected TransmissionManagerWrapper getTopicTransmissionManagerWrapper(
0371:                    int indexOfSession) {
0372:                return jmsTestModule
0373:                        .getTopicTransmissionManagerWrapper(indexOfSession);
0374:            }
0375:
0376:            /**
0377:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getQueueSessionList}
0378:             */
0379:            protected List getQueueSessionList() {
0380:                return jmsTestModule.getQueueSessionList();
0381:            }
0382:
0383:            /**
0384:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTopicSessionList}
0385:             */
0386:            protected List getTopicSessionList() {
0387:                return jmsTestModule.getTopicSessionList();
0388:            }
0389:
0390:            /**
0391:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getSessionList}
0392:             */
0393:            protected List getSessionList() {
0394:                return jmsTestModule.getSessionList();
0395:            }
0396:
0397:            /**
0398:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTemporaryQueueList(int)}
0399:             */
0400:            protected List getTemporaryQueueList(int indexOfSession) {
0401:                return jmsTestModule.getTemporaryQueueList(indexOfSession);
0402:            }
0403:
0404:            /**
0405:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTemporaryTopicList(int)}
0406:             */
0407:            protected List getTemporaryTopicList(int indexOfSession) {
0408:                return jmsTestModule.getTemporaryTopicList(indexOfSession);
0409:            }
0410:
0411:            /**
0412:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTemporaryQueue(int, int)}
0413:             */
0414:            protected MockTemporaryQueue getTemporaryQueue(int indexOfSession,
0415:                    int indexOfQueue) {
0416:                return jmsTestModule.getTemporaryQueue(indexOfSession,
0417:                        indexOfQueue);
0418:            }
0419:
0420:            /**
0421:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getTemporaryTopic(int, int)}
0422:             */
0423:            protected MockTemporaryTopic getTemporaryTopic(int indexOfSession,
0424:                    int indexOfTopic) {
0425:                return jmsTestModule.getTemporaryTopic(indexOfSession,
0426:                        indexOfTopic);
0427:            }
0428:
0429:            /**
0430:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getCurrentMessageListFromQueue(String)}
0431:             */
0432:            protected List getCurrentMessageListFromQueue(String name) {
0433:                return jmsTestModule.getCurrentMessageListFromQueue(name);
0434:            }
0435:
0436:            /**
0437:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getCurrentMessageListFromTemporaryQueue(int, int)}
0438:             */
0439:            protected List getCurrentMessageListFromTemporaryQueue(
0440:                    int indexOfSession, int indexOfQueue) {
0441:                return jmsTestModule.getCurrentMessageListFromTemporaryQueue(
0442:                        indexOfSession, indexOfQueue);
0443:            }
0444:
0445:            /**
0446:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getReceivedMessageListFromQueue(String)}
0447:             */
0448:            protected List getReceivedMessageListFromQueue(String name) {
0449:                return jmsTestModule.getReceivedMessageListFromQueue(name);
0450:            }
0451:
0452:            /**
0453:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getReceivedMessageListFromTemporaryQueue(int, int)}
0454:             */
0455:            protected List getReceivedMessageListFromTemporaryQueue(
0456:                    int indexOfSession, int indexOfQueue) {
0457:                return jmsTestModule.getReceivedMessageListFromTemporaryQueue(
0458:                        indexOfSession, indexOfQueue);
0459:            }
0460:
0461:            /**
0462:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getCurrentMessageListFromTopic(String)}
0463:             */
0464:            protected List getCurrentMessageListFromTopic(String name) {
0465:                return jmsTestModule.getCurrentMessageListFromTopic(name);
0466:            }
0467:
0468:            /**
0469:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getCurrentMessageListFromTemporaryTopic(int, int)}
0470:             */
0471:            protected List getCurrentMessageListFromTemporaryTopic(
0472:                    int indexOfSession, int indexOfTopic) {
0473:                return jmsTestModule.getCurrentMessageListFromTemporaryTopic(
0474:                        indexOfSession, indexOfTopic);
0475:            }
0476:
0477:            /**
0478:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getReceivedMessageListFromTopic(String)}
0479:             */
0480:            protected List getReceivedMessageListFromTopic(String name) {
0481:                return jmsTestModule.getReceivedMessageListFromTopic(name);
0482:            }
0483:
0484:            /**
0485:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getReceivedMessageListFromTemporaryTopic(int, int)}
0486:             */
0487:            protected List getReceivedMessageListFromTemporaryTopic(
0488:                    int indexOfSession, int indexOfTopic) {
0489:                return jmsTestModule.getReceivedMessageListFromTemporaryTopic(
0490:                        indexOfSession, indexOfTopic);
0491:            }
0492:
0493:            /**
0494:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueConnectionClosed}
0495:             */
0496:            protected void verifyQueueConnectionClosed() {
0497:                jmsTestModule.verifyQueueConnectionClosed();
0498:            }
0499:
0500:            /**
0501:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueConnectionStarted}
0502:             */
0503:            protected void verifyQueueConnectionStarted() {
0504:                jmsTestModule.verifyQueueConnectionStarted();
0505:            }
0506:
0507:            /**
0508:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueConnectionStopped}
0509:             */
0510:            protected void verifyQueueConnectionStopped() {
0511:                jmsTestModule.verifyQueueConnectionStopped();
0512:            }
0513:
0514:            /**
0515:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicConnectionClosed}
0516:             */
0517:            protected void verifyTopicConnectionClosed() {
0518:                jmsTestModule.verifyTopicConnectionClosed();
0519:            }
0520:
0521:            /**
0522:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicConnectionStarted}
0523:             */
0524:            protected void verifyTopicConnectionStarted() {
0525:                jmsTestModule.verifyTopicConnectionStarted();
0526:            }
0527:
0528:            /**
0529:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicConnectionStopped}
0530:             */
0531:            protected void verifyTopicConnectionStopped() {
0532:                jmsTestModule.verifyTopicConnectionStopped();
0533:            }
0534:
0535:            /**
0536:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyConnectionStarted}
0537:             */
0538:            protected void verifyConnectionStarted() {
0539:                jmsTestModule.verifyConnectionStarted();
0540:            }
0541:
0542:            /**
0543:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyConnectionStopped}
0544:             */
0545:            protected void verifyConnectionStopped() {
0546:                jmsTestModule.verifyConnectionStopped();
0547:            }
0548:
0549:            /**
0550:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionClosed(int)}
0551:             */
0552:            protected void verifyQueueSessionClosed(int indexOfSession) {
0553:                jmsTestModule.verifyQueueSessionClosed(indexOfSession);
0554:            }
0555:
0556:            /**
0557:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionCommitted(int)}
0558:             */
0559:            protected void verifyQueueSessionCommitted(int indexOfSession) {
0560:                jmsTestModule.verifyQueueSessionCommitted(indexOfSession);
0561:            }
0562:
0563:            /**
0564:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionNotCommitted(int)}
0565:             */
0566:            protected void verifyQueueSessionNotCommitted(int indexOfSession) {
0567:                jmsTestModule.verifyQueueSessionNotCommitted(indexOfSession);
0568:            }
0569:
0570:            /**
0571:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionNumberCommits(int, int)}
0572:             */
0573:            protected void verifyQueueSessionNumberCommits(int indexOfSession,
0574:                    int numberOfCommits) {
0575:                jmsTestModule.verifyQueueSessionNumberCommits(indexOfSession,
0576:                        numberOfCommits);
0577:            }
0578:
0579:            /**
0580:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionRolledBack(int)}
0581:             */
0582:            protected void verifyQueueSessionRolledBack(int indexOfSession) {
0583:                jmsTestModule.verifyQueueSessionRolledBack(indexOfSession);
0584:            }
0585:
0586:            /**
0587:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionNotRolledBack(int)}
0588:             */
0589:            protected void verifyQueueSessionNotRolledBack(int indexOfSession) {
0590:                jmsTestModule.verifyQueueSessionNotRolledBack(indexOfSession);
0591:            }
0592:
0593:            /**
0594:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionNumberRollbacks(int, int)}
0595:             */
0596:            protected void verifyQueueSessionNumberRollbacks(
0597:                    int indexOfSession, int numberOfRollbacks) {
0598:                jmsTestModule.verifyQueueSessionNumberRollbacks(indexOfSession,
0599:                        numberOfRollbacks);
0600:            }
0601:
0602:            /**
0603:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionRecovered(int)}
0604:             */
0605:            protected void verifyQueueSessionRecovered(int indexOfSession) {
0606:                jmsTestModule.verifyQueueSessionRecovered(indexOfSession);
0607:            }
0608:
0609:            /**
0610:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSessionNotRecovered(int)}
0611:             */
0612:            protected void verifyQueueSessionNotRecovered(int indexOfSession) {
0613:                jmsTestModule.verifyQueueSessionNotRecovered(indexOfSession);
0614:            }
0615:
0616:            /**
0617:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionClosed(int)}
0618:             */
0619:            protected void verifyTopicSessionClosed(int indexOfSession) {
0620:                jmsTestModule.verifyTopicSessionClosed(indexOfSession);
0621:            }
0622:
0623:            /**
0624:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionCommitted(int)}
0625:             */
0626:            protected void verifyTopicSessionCommitted(int indexOfSession) {
0627:                jmsTestModule.verifyTopicSessionCommitted(indexOfSession);
0628:            }
0629:
0630:            /**
0631:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionNotCommitted(int)}
0632:             */
0633:            protected void verifyTopicSessionNotCommitted(int indexOfSession) {
0634:                jmsTestModule.verifyTopicSessionNotCommitted(indexOfSession);
0635:            }
0636:
0637:            /**
0638:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionNumberCommits(int, int)}
0639:             */
0640:            protected void verifyTopicSessionNumberCommits(int indexOfSession,
0641:                    int numberOfCommits) {
0642:                jmsTestModule.verifyTopicSessionNumberCommits(indexOfSession,
0643:                        numberOfCommits);
0644:            }
0645:
0646:            /**
0647:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionRolledBack(int)}
0648:             */
0649:            protected void verifyTopicSessionRolledBack(int indexOfSession) {
0650:                jmsTestModule.verifyTopicSessionRolledBack(indexOfSession);
0651:            }
0652:
0653:            /**
0654:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionNotRolledBack(int)}
0655:             */
0656:            protected void verifyTopicSessionNotRolledBack(int indexOfSession) {
0657:                jmsTestModule.verifyTopicSessionNotRolledBack(indexOfSession);
0658:            }
0659:
0660:            /**
0661:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionNumberRollbacks(int, int)}
0662:             */
0663:            protected void verifyTopicSessionNumberRollbacks(
0664:                    int indexOfSession, int numberOfRollbacks) {
0665:                jmsTestModule.verifyTopicSessionNumberRollbacks(indexOfSession,
0666:                        numberOfRollbacks);
0667:            }
0668:
0669:            /**
0670:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionRecovered(int)}
0671:             */
0672:            protected void verifyTopicSessionRecovered(int indexOfSession) {
0673:                jmsTestModule.verifyTopicSessionRecovered(indexOfSession);
0674:            }
0675:
0676:            /**
0677:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSessionNotRecovered(int)}
0678:             */
0679:            protected void verifyTopicSessionNotRecovered(int indexOfSession) {
0680:                jmsTestModule.verifyTopicSessionNotRecovered(indexOfSession);
0681:            }
0682:
0683:            /**
0684:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionClosed(int)}
0685:             */
0686:            protected void verifySessionClosed(int indexOfSession) {
0687:                jmsTestModule.verifySessionClosed(indexOfSession);
0688:            }
0689:
0690:            /**
0691:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionCommitted(int)}
0692:             */
0693:            protected void verifySessionCommitted(int indexOfSession) {
0694:                jmsTestModule.verifySessionCommitted(indexOfSession);
0695:            }
0696:
0697:            /**
0698:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionNotCommitted(int)}
0699:             */
0700:            protected void verifySessionNotCommitted(int indexOfSession) {
0701:                jmsTestModule.verifySessionNotCommitted(indexOfSession);
0702:            }
0703:
0704:            /**
0705:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionNumberCommits(int, int)}
0706:             */
0707:            protected void verifySessionNumberCommits(int indexOfSession,
0708:                    int numberOfCommits) {
0709:                jmsTestModule.verifySessionNumberCommits(indexOfSession,
0710:                        numberOfCommits);
0711:            }
0712:
0713:            /**
0714:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionRolledBack(int)}
0715:             */
0716:            protected void verifySessionRolledBack(int indexOfSession) {
0717:                jmsTestModule.verifySessionRolledBack(indexOfSession);
0718:            }
0719:
0720:            /**
0721:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionNotRolledBack(int)}
0722:             */
0723:            protected void verifySessionNotRolledBack(int indexOfSession) {
0724:                jmsTestModule.verifySessionNotRolledBack(indexOfSession);
0725:            }
0726:
0727:            /**
0728:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionNumberRollbacks(int, int)}
0729:             */
0730:            protected void verifySessionNumberRollbacks(int indexOfSession,
0731:                    int numberOfRollbacks) {
0732:                jmsTestModule.verifySessionNumberRollbacks(indexOfSession,
0733:                        numberOfRollbacks);
0734:            }
0735:
0736:            /**
0737:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionRecovered(int)}
0738:             */
0739:            protected void verifySessionRecovered(int indexOfSession) {
0740:                jmsTestModule.verifySessionRecovered(indexOfSession);
0741:            }
0742:
0743:            /**
0744:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifySessionNotRecovered(int)}
0745:             */
0746:            protected void verifySessionNotRecovered(int indexOfSession) {
0747:                jmsTestModule.verifySessionNotRecovered(indexOfSession);
0748:            }
0749:
0750:            /**
0751:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllQueueSessionsClosed}
0752:             */
0753:            protected void verifyAllQueueSessionsClosed() {
0754:                jmsTestModule.verifyAllQueueSessionsClosed();
0755:            }
0756:
0757:            /**
0758:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllQueueSessionsRecovered}
0759:             */
0760:            protected void verifyAllQueueSessionsRecovered() {
0761:                jmsTestModule.verifyAllQueueSessionsRecovered();
0762:            }
0763:
0764:            /**
0765:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllQueueSessionsCommitted}
0766:             */
0767:            protected void verifyAllQueueSessionsCommitted() {
0768:                jmsTestModule.verifyAllQueueSessionsCommitted();
0769:            }
0770:
0771:            /**
0772:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllQueueSessionsRolledBack}
0773:             */
0774:            protected void verifyAllQueueSessionsRolledBack() {
0775:                jmsTestModule.verifyAllQueueSessionsRolledBack();
0776:            }
0777:
0778:            /**
0779:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTopicSessionsClosed}
0780:             */
0781:            protected void verifyAllTopicSessionsClosed() {
0782:                jmsTestModule.verifyAllTopicSessionsClosed();
0783:            }
0784:
0785:            /**
0786:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTopicSessionsRecovered}
0787:             */
0788:            protected void verifyAllTopicSessionsRecovered() {
0789:                jmsTestModule.verifyAllTopicSessionsRecovered();
0790:            }
0791:
0792:            /**
0793:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTopicSessionsCommitted}
0794:             */
0795:            protected void verifyAllTopicSessionsCommitted() {
0796:                jmsTestModule.verifyAllTopicSessionsCommitted();
0797:            }
0798:
0799:            /**
0800:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTopicSessionsRolledBack}
0801:             */
0802:            protected void verifyAllTopicSessionsRolledBack() {
0803:                jmsTestModule.verifyAllTopicSessionsRolledBack();
0804:            }
0805:
0806:            /**
0807:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllSessionsClosed}
0808:             */
0809:            protected void verifyAllSessionsClosed() {
0810:                jmsTestModule.verifyAllSessionsClosed();
0811:            }
0812:
0813:            /**
0814:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllSessionsRecovered}
0815:             */
0816:            protected void verifyAllSessionsRecovered() {
0817:                jmsTestModule.verifyAllSessionsRecovered();
0818:            }
0819:
0820:            /**
0821:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllSessionsCommitted}
0822:             */
0823:            protected void verifyAllSessionsCommitted() {
0824:                jmsTestModule.verifyAllSessionsCommitted();
0825:            }
0826:
0827:            /**
0828:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllSessionsRolledBack}
0829:             */
0830:            protected void verifyAllSessionsRolledBack() {
0831:                jmsTestModule.verifyAllSessionsRolledBack();
0832:            }
0833:
0834:            /**
0835:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberMessageProducers(int, int)}
0836:             */
0837:            protected void verifyNumberMessageProducers(int indexOfSession,
0838:                    int numberOfProducers) {
0839:                jmsTestModule.verifyNumberMessageProducers(indexOfSession,
0840:                        numberOfProducers);
0841:            }
0842:
0843:            /**
0844:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllMessageProducersClosed(int)}
0845:             */
0846:            protected void verifyAllMessageProducersClosed(int indexOfSession) {
0847:                jmsTestModule.verifyAllMessageProducersClosed(indexOfSession);
0848:            }
0849:
0850:            /**
0851:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberQueueSenders(int, String, int)}
0852:             */
0853:            protected void verifyNumberQueueSenders(int indexOfSession,
0854:                    String queueName, int numberOfSenders) {
0855:                jmsTestModule.verifyNumberQueueSenders(indexOfSession,
0856:                        queueName, numberOfSenders);
0857:            }
0858:
0859:            /**
0860:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberQueueSenders(int, int)}
0861:             */
0862:            protected void verifyNumberQueueSenders(int indexOfSession,
0863:                    int numberOfSenders) {
0864:                jmsTestModule.verifyNumberQueueSenders(indexOfSession,
0865:                        numberOfSenders);
0866:            }
0867:
0868:            /**
0869:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueSenderClosed(int, String, int)}
0870:             */
0871:            protected void verifyQueueSenderClosed(int indexOfSession,
0872:                    String queueName, int indexOfSender) {
0873:                jmsTestModule.verifyQueueSenderClosed(indexOfSession,
0874:                        queueName, indexOfSender);
0875:            }
0876:
0877:            /**
0878:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllQueueSendersClosed(int)}
0879:             */
0880:            protected void verifyAllQueueSendersClosed(int indexOfSession) {
0881:                jmsTestModule.verifyAllQueueSendersClosed(indexOfSession);
0882:            }
0883:
0884:            /**
0885:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberTopicPublishers(int, String, int)}
0886:             */
0887:            protected void verifyNumberTopicPublishers(int indexOfSession,
0888:                    String topicName, int numberOfPublishers) {
0889:                jmsTestModule.verifyNumberTopicPublishers(indexOfSession,
0890:                        topicName, numberOfPublishers);
0891:            }
0892:
0893:            /**
0894:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberTopicPublishers(int, int)}
0895:             */
0896:            protected void verifyNumberTopicPublishers(int indexOfSession,
0897:                    int numberOfPublishers) {
0898:                jmsTestModule.verifyNumberTopicPublishers(indexOfSession,
0899:                        numberOfPublishers);
0900:            }
0901:
0902:            /**
0903:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicPublisherClosed(int, String, int)}
0904:             */
0905:            protected void verifyTopicPublisherClosed(int indexOfSession,
0906:                    String topicName, int indexOfPublisher) {
0907:                jmsTestModule.verifyTopicPublisherClosed(indexOfSession,
0908:                        topicName, indexOfPublisher);
0909:            }
0910:
0911:            /**
0912:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTopicPublishersClosed(int)}
0913:             */
0914:            protected void verifyAllTopicPublishersClosed(int indexOfSession) {
0915:                jmsTestModule.verifyAllTopicPublishersClosed(indexOfSession);
0916:            }
0917:
0918:            /**
0919:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberMessageConsumers(int, int)}
0920:             */
0921:            protected void verifyNumberMessageConsumers(int indexOfSession,
0922:                    int numberOfConsumers) {
0923:                jmsTestModule.verifyNumberMessageConsumers(indexOfSession,
0924:                        numberOfConsumers);
0925:            }
0926:
0927:            /**
0928:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllMessageConsumersClosed(int)}
0929:             */
0930:            protected void verifyAllMessageConsumersClosed(int indexOfSession) {
0931:                jmsTestModule.verifyAllMessageConsumersClosed(indexOfSession);
0932:            }
0933:
0934:            /**
0935:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberQueueReceivers(int, int)}
0936:             */
0937:            protected void verifyNumberQueueReceivers(int indexOfSession,
0938:                    int numberOfReceivers) {
0939:                jmsTestModule.verifyNumberQueueReceivers(indexOfSession,
0940:                        numberOfReceivers);
0941:            }
0942:
0943:            /**
0944:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberQueueReceivers(int, String, int)}
0945:             */
0946:            protected void verifyNumberQueueReceivers(int indexOfSession,
0947:                    String queueName, int numberOfReceivers) {
0948:                jmsTestModule.verifyNumberQueueReceivers(indexOfSession,
0949:                        queueName, numberOfReceivers);
0950:            }
0951:
0952:            /**
0953:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueReceiverClosed(int, String, int)}
0954:             */
0955:            protected void verifyQueueReceiverClosed(int indexOfSession,
0956:                    String queueName, int indexOfReceiver) {
0957:                jmsTestModule.verifyQueueReceiverClosed(indexOfSession,
0958:                        queueName, indexOfReceiver);
0959:            }
0960:
0961:            /**
0962:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllQueueReceiversClosed(int)}
0963:             */
0964:            protected void verifyAllQueueReceiversClosed(int indexOfSession) {
0965:                jmsTestModule.verifyAllQueueReceiversClosed(indexOfSession);
0966:            }
0967:
0968:            /**
0969:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberTopicSubscribers(int, int)}
0970:             */
0971:            protected void verifyNumberTopicSubscribers(int indexOfSession,
0972:                    int numberOfSubscribers) {
0973:                jmsTestModule.verifyNumberTopicSubscribers(indexOfSession,
0974:                        numberOfSubscribers);
0975:            }
0976:
0977:            /**
0978:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberTopicSubscribers(int, String, int)}
0979:             */
0980:            protected void verifyNumberTopicSubscribers(int indexOfSession,
0981:                    String topicName, int numberOfSubscribers) {
0982:                jmsTestModule.verifyNumberTopicSubscribers(indexOfSession,
0983:                        topicName, numberOfSubscribers);
0984:            }
0985:
0986:            /**
0987:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTopicSubscriberClosed(int, String, int)}
0988:             */
0989:            protected void verifyTopicSubscriberClosed(int indexOfSession,
0990:                    String topicName, int indexOfSubscriber) {
0991:                jmsTestModule.verifyTopicSubscriberClosed(indexOfSession,
0992:                        topicName, indexOfSubscriber);
0993:            }
0994:
0995:            /**
0996:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTopicSubscribersClosed(int)}
0997:             */
0998:            protected void verifyAllTopicSubscribersClosed(int indexOfSession) {
0999:                jmsTestModule.verifyAllTopicSubscribersClosed(indexOfSession);
1000:            }
1001:
1002:            /**
1003:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberQueueBrowsers(int, String, int)}
1004:             */
1005:            protected void verifyNumberQueueBrowsers(int indexOfSession,
1006:                    String queueName, int numberOfBrowsers) {
1007:                jmsTestModule.verifyNumberQueueBrowsers(indexOfSession,
1008:                        queueName, numberOfBrowsers);
1009:            }
1010:
1011:            /**
1012:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberQueueBrowsers(int, int)}
1013:             */
1014:            protected void verifyNumberQueueBrowsers(int indexOfSession,
1015:                    int numberOfBrowsers) {
1016:                jmsTestModule.verifyNumberQueueBrowsers(indexOfSession,
1017:                        numberOfBrowsers);
1018:            }
1019:
1020:            /**
1021:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyQueueBrowserClosed(int, String, int)}
1022:             */
1023:            protected void verifyQueueBrowserClosed(int indexOfSession,
1024:                    String queueName, int indexOfBrowser) {
1025:                jmsTestModule.verifyQueueBrowserClosed(indexOfSession,
1026:                        queueName, indexOfBrowser);
1027:            }
1028:
1029:            /**
1030:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllQueueBrowsersClosed(int)}
1031:             */
1032:            protected void verifyAllQueueBrowsersClosed(int indexOfSession) {
1033:                jmsTestModule.verifyAllQueueBrowsersClosed(indexOfSession);
1034:            }
1035:
1036:            /**
1037:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyDurableTopicSubscriberPresent(int, String)}
1038:             */
1039:            protected void verifyDurableTopicSubscriberPresent(
1040:                    int indexOfSession, String name) {
1041:                jmsTestModule.verifyDurableTopicSubscriberPresent(
1042:                        indexOfSession, name);
1043:            }
1044:
1045:            /**
1046:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberDurableTopicSubscribers(int, String, int)}
1047:             */
1048:            protected void verifyNumberDurableTopicSubscribers(
1049:                    int indexOfSession, String topicName,
1050:                    int numberOfSubscribers) {
1051:                jmsTestModule.verifyNumberDurableTopicSubscribers(
1052:                        indexOfSession, topicName, numberOfSubscribers);
1053:            }
1054:
1055:            /**
1056:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberDurableTopicSubscribers(int, int)}
1057:             */
1058:            protected void verifyNumberDurableTopicSubscribers(
1059:                    int indexOfSession, int numberOfSubscribers) {
1060:                jmsTestModule.verifyNumberDurableTopicSubscribers(
1061:                        indexOfSession, numberOfSubscribers);
1062:            }
1063:
1064:            /**
1065:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyDurableTopicSubscriberClosed(int, String)}
1066:             */
1067:            protected void verifyDurableTopicSubscriberClosed(
1068:                    int indexOfSession, String name) {
1069:                jmsTestModule.verifyDurableTopicSubscriberClosed(
1070:                        indexOfSession, name);
1071:            }
1072:
1073:            /**
1074:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllDurableTopicSubscribersClosed(int)}
1075:             */
1076:            protected void verifyAllDurableTopicSubscribersClosed(
1077:                    int indexOfSession) {
1078:                jmsTestModule
1079:                        .verifyAllDurableTopicSubscribersClosed(indexOfSession);
1080:            }
1081:
1082:            /**
1083:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberQueueSessions(int)}
1084:             */
1085:            protected void verifyNumberQueueSessions(int number) {
1086:                jmsTestModule.verifyNumberQueueSessions(number);
1087:            }
1088:
1089:            /**
1090:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberTopicSessions(int)}
1091:             */
1092:            protected void verifyNumberTopicSessions(int number) {
1093:                jmsTestModule.verifyNumberTopicSessions(number);
1094:            }
1095:
1096:            /**
1097:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberSessions(int)}
1098:             */
1099:            protected void verifyNumberSessions(int number) {
1100:                jmsTestModule.verifyNumberSessions(number);
1101:            }
1102:
1103:            /**
1104:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberTemporaryQueues(int, int)}
1105:             */
1106:            protected void verifyNumberTemporaryQueues(int indexOfSession,
1107:                    int numberQueues) {
1108:                jmsTestModule.verifyNumberTemporaryQueues(indexOfSession,
1109:                        numberQueues);
1110:            }
1111:
1112:            /**
1113:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberTemporaryTopics(int, int)}
1114:             */
1115:            protected void verifyNumberTemporaryTopics(int indexOfSession,
1116:                    int numberTopics) {
1117:                jmsTestModule.verifyNumberTemporaryTopics(indexOfSession,
1118:                        numberTopics);
1119:            }
1120:
1121:            /**
1122:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTemporaryQueueDeleted(int, int)}
1123:             */
1124:            protected void verifyTemporaryQueueDeleted(int indexOfSession,
1125:                    int indexOfQueue) {
1126:                jmsTestModule.verifyTemporaryQueueDeleted(indexOfSession,
1127:                        indexOfQueue);
1128:            }
1129:
1130:            /**
1131:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTemporaryQueuesDeleted(int)}
1132:             */
1133:            protected void verifyAllTemporaryQueuesDeleted(int indexOfSession) {
1134:                jmsTestModule.verifyAllTemporaryQueuesDeleted(indexOfSession);
1135:            }
1136:
1137:            /**
1138:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyTemporaryTopicDeleted(int, int)}
1139:             */
1140:            protected void verifyTemporaryTopicDeleted(int indexOfSession,
1141:                    int indexOfTopic) {
1142:                jmsTestModule.verifyTemporaryTopicDeleted(indexOfSession,
1143:                        indexOfTopic);
1144:            }
1145:
1146:            /**
1147:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllTemporaryTopicsDeleted(int)}
1148:             */
1149:            protected void verifyAllTemporaryTopicsDeleted(int indexOfSession) {
1150:                jmsTestModule.verifyAllTemporaryTopicsDeleted(indexOfSession);
1151:            }
1152:
1153:            /**
1154:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyMessageEquals(MockMessage, MockMessage)}
1155:             */
1156:            protected void verifyMessageEquals(MockMessage message1,
1157:                    MockMessage message2) {
1158:                jmsTestModule.verifyMessageEquals(message1, message2);
1159:            }
1160:
1161:            /**
1162:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCurrentQueueMessageEquals(String, int, MockMessage)}
1163:             */
1164:            protected void verifyCurrentQueueMessageEquals(String nameOfQueue,
1165:                    int indexOfSourceMessage, MockMessage targetMessage) {
1166:                jmsTestModule.verifyCurrentQueueMessageEquals(nameOfQueue,
1167:                        indexOfSourceMessage, targetMessage);
1168:            }
1169:
1170:            /**
1171:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCurrentQueueMessageEquals(int, int, int, MockMessage)}
1172:             */
1173:            protected void verifyCurrentQueueMessageEquals(int indexOfSession,
1174:                    int indexOfQueue, int indexOfSourceMessage,
1175:                    MockMessage targetMessage) {
1176:                jmsTestModule.verifyCurrentQueueMessageEquals(indexOfSession,
1177:                        indexOfQueue, indexOfSourceMessage, targetMessage);
1178:            }
1179:
1180:            /**
1181:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedQueueMessageEquals(String, int, MockMessage)}
1182:             */
1183:            protected void verifyReceivedQueueMessageEquals(String nameOfQueue,
1184:                    int indexOfSourceMessage, MockMessage targetMessage) {
1185:                jmsTestModule.verifyReceivedQueueMessageEquals(nameOfQueue,
1186:                        indexOfSourceMessage, targetMessage);
1187:            }
1188:
1189:            /**
1190:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedQueueMessageEquals(int, int, int, MockMessage)}
1191:             */
1192:            protected void verifyReceivedQueueMessageEquals(int indexOfSession,
1193:                    int indexOfQueue, int indexOfSourceMessage,
1194:                    MockMessage targetMessage) {
1195:                jmsTestModule.verifyReceivedQueueMessageEquals(indexOfSession,
1196:                        indexOfQueue, indexOfSourceMessage, targetMessage);
1197:            }
1198:
1199:            /**
1200:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCurrentQueueMessages(int, int, int)}
1201:             */
1202:            protected void verifyNumberOfCurrentQueueMessages(
1203:                    int indexOfSession, int indexOfQueue, int numberOfMessages) {
1204:                jmsTestModule.verifyNumberOfCurrentQueueMessages(
1205:                        indexOfSession, indexOfQueue, numberOfMessages);
1206:            }
1207:
1208:            /**
1209:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCurrentQueueMessages(String, int)}
1210:             */
1211:            protected void verifyNumberOfCurrentQueueMessages(
1212:                    String nameOfQueue, int numberOfMessages) {
1213:                jmsTestModule.verifyNumberOfCurrentQueueMessages(nameOfQueue,
1214:                        numberOfMessages);
1215:            }
1216:
1217:            /**
1218:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfReceivedQueueMessages(String, int)}
1219:             */
1220:            protected void verifyNumberOfReceivedQueueMessages(
1221:                    String nameOfQueue, int numberOfMessages) {
1222:                jmsTestModule.verifyNumberOfReceivedQueueMessages(nameOfQueue,
1223:                        numberOfMessages);
1224:            }
1225:
1226:            /**
1227:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfReceivedQueueMessages(int, int, int)}
1228:             */
1229:            protected void verifyNumberOfReceivedQueueMessages(
1230:                    int indexOfSession, int indexOfQueue, int numberOfMessages) {
1231:                jmsTestModule.verifyNumberOfReceivedQueueMessages(
1232:                        indexOfSession, indexOfQueue, numberOfMessages);
1233:            }
1234:
1235:            /**
1236:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllReceivedQueueMessagesAcknowledged(String)}
1237:             */
1238:            protected void verifyAllReceivedQueueMessagesAcknowledged(
1239:                    String nameOfQueue) {
1240:                jmsTestModule
1241:                        .verifyAllReceivedQueueMessagesAcknowledged(nameOfQueue);
1242:            }
1243:
1244:            /**
1245:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllReceivedQueueMessagesAcknowledged(int, int)}
1246:             */
1247:            protected void verifyAllReceivedQueueMessagesAcknowledged(
1248:                    int indexOfSession, int indexOfQueue) {
1249:                jmsTestModule.verifyAllReceivedQueueMessagesAcknowledged(
1250:                        indexOfSession, indexOfQueue);
1251:            }
1252:
1253:            /**
1254:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedQueueMessageAcknowledged(String, int)}
1255:             */
1256:            protected void verifyReceivedQueueMessageAcknowledged(
1257:                    String nameOfQueue, int indexOfMessage) {
1258:                jmsTestModule.verifyReceivedQueueMessageAcknowledged(
1259:                        nameOfQueue, indexOfMessage);
1260:            }
1261:
1262:            /**
1263:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedQueueMessageAcknowledged(int, int, int)}
1264:             */
1265:            protected void verifyReceivedQueueMessageAcknowledged(
1266:                    int indexOfSession, int indexOfQueue, int indexOfMessage) {
1267:                jmsTestModule.verifyReceivedQueueMessageAcknowledged(
1268:                        indexOfSession, indexOfQueue, indexOfMessage);
1269:            }
1270:
1271:            /**
1272:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedQueueMessageNotAcknowledged(int, int, int)}
1273:             */
1274:            protected void verifyReceivedQueueMessageNotAcknowledged(
1275:                    int indexOfSession, int indexOfQueue, int indexOfMessage) {
1276:                jmsTestModule.verifyReceivedQueueMessageNotAcknowledged(
1277:                        indexOfSession, indexOfQueue, indexOfMessage);
1278:            }
1279:
1280:            /**
1281:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedQueueMessageNotAcknowledged(String, int)}
1282:             */
1283:            protected void verifyReceivedQueueMessageNotAcknowledged(
1284:                    String nameOfQueue, int indexOfMessage) {
1285:                jmsTestModule.verifyReceivedQueueMessageNotAcknowledged(
1286:                        nameOfQueue, indexOfMessage);
1287:            }
1288:
1289:            /**
1290:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedQueueMessages(int, int)}
1291:             */
1292:            protected void verifyNumberOfCreatedQueueMessages(
1293:                    int indexOfSession, int number) {
1294:                jmsTestModule.verifyNumberOfCreatedQueueMessages(
1295:                        indexOfSession, number);
1296:            }
1297:
1298:            /**
1299:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedQueueBytesMessages(int, int)}
1300:             */
1301:            protected void verifyNumberOfCreatedQueueBytesMessages(
1302:                    int indexOfSession, int number) {
1303:                jmsTestModule.verifyNumberOfCreatedQueueBytesMessages(
1304:                        indexOfSession, number);
1305:            }
1306:
1307:            /**
1308:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedQueueMapMessages(int, int)}
1309:             */
1310:            protected void verifyNumberOfCreatedQueueMapMessages(
1311:                    int indexOfSession, int number) {
1312:                jmsTestModule.verifyNumberOfCreatedQueueMapMessages(
1313:                        indexOfSession, number);
1314:            }
1315:
1316:            /**
1317:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedQueueTextMessages(int, int)}
1318:             */
1319:            protected void verifyNumberOfCreatedQueueTextMessages(
1320:                    int indexOfSession, int number) {
1321:                jmsTestModule.verifyNumberOfCreatedQueueTextMessages(
1322:                        indexOfSession, number);
1323:            }
1324:
1325:            /**
1326:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedQueueStreamMessages(int, int)}
1327:             */
1328:            protected void verifyNumberOfCreatedQueueStreamMessages(
1329:                    int indexOfSession, int number) {
1330:                jmsTestModule.verifyNumberOfCreatedQueueStreamMessages(
1331:                        indexOfSession, number);
1332:            }
1333:
1334:            /**
1335:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedQueueObjectMessages(int, int)}
1336:             */
1337:            protected void verifyNumberOfCreatedQueueObjectMessages(
1338:                    int indexOfSession, int number) {
1339:                jmsTestModule.verifyNumberOfCreatedQueueObjectMessages(
1340:                        indexOfSession, number);
1341:            }
1342:
1343:            /**
1344:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueMessageAcknowledged(int, int)}
1345:             */
1346:            protected void verifyCreatedQueueMessageAcknowledged(
1347:                    int indexOfSession, int indexOfMessage) {
1348:                jmsTestModule.verifyCreatedQueueMessageAcknowledged(
1349:                        indexOfSession, indexOfMessage);
1350:            }
1351:
1352:            /**
1353:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueMessageNotAcknowledged(int, int)}
1354:             */
1355:            protected void verifyCreatedQueueMessageNotAcknowledged(
1356:                    int indexOfSession, int indexOfMessage) {
1357:                jmsTestModule.verifyCreatedQueueMessageNotAcknowledged(
1358:                        indexOfSession, indexOfMessage);
1359:            }
1360:
1361:            /**
1362:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueBytesMessageAcknowledged(int, int)}
1363:             */
1364:            protected void verifyCreatedQueueBytesMessageAcknowledged(
1365:                    int indexOfSession, int indexOfMessage) {
1366:                jmsTestModule.verifyCreatedQueueBytesMessageAcknowledged(
1367:                        indexOfSession, indexOfMessage);
1368:            }
1369:
1370:            /**
1371:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueBytesMessageNotAcknowledged(int, int)}
1372:             */
1373:            protected void verifyCreatedQueueBytesMessageNotAcknowledged(
1374:                    int indexOfSession, int indexOfMessage) {
1375:                jmsTestModule.verifyCreatedQueueBytesMessageNotAcknowledged(
1376:                        indexOfSession, indexOfMessage);
1377:            }
1378:
1379:            /**
1380:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueMapMessageAcknowledged(int, int)}
1381:             */
1382:            protected void verifyCreatedQueueMapMessageAcknowledged(
1383:                    int indexOfSession, int indexOfMessage) {
1384:                jmsTestModule.verifyCreatedQueueMapMessageAcknowledged(
1385:                        indexOfSession, indexOfMessage);
1386:            }
1387:
1388:            /**
1389:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueMapMessageNotAcknowledged(int, int)}
1390:             */
1391:            protected void verifyCreatedQueueMapMessageNotAcknowledged(
1392:                    int indexOfSession, int indexOfMessage) {
1393:                jmsTestModule.verifyCreatedQueueMapMessageNotAcknowledged(
1394:                        indexOfSession, indexOfMessage);
1395:            }
1396:
1397:            /**
1398:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueTextMessageAcknowledged(int, int)}
1399:             */
1400:            protected void verifyCreatedQueueTextMessageAcknowledged(
1401:                    int indexOfSession, int indexOfMessage) {
1402:                jmsTestModule.verifyCreatedQueueTextMessageAcknowledged(
1403:                        indexOfSession, indexOfMessage);
1404:            }
1405:
1406:            /**
1407:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueTextMessageNotAcknowledged(int, int)}
1408:             */
1409:            protected void verifyCreatedQueueTextMessageNotAcknowledged(
1410:                    int indexOfSession, int indexOfMessage) {
1411:                jmsTestModule.verifyCreatedQueueTextMessageNotAcknowledged(
1412:                        indexOfSession, indexOfMessage);
1413:            }
1414:
1415:            /**
1416:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueStreamMessageAcknowledged(int, int)}
1417:             */
1418:            protected void verifyCreatedQueueStreamMessageAcknowledged(
1419:                    int indexOfSession, int indexOfMessage) {
1420:                jmsTestModule.verifyCreatedQueueStreamMessageAcknowledged(
1421:                        indexOfSession, indexOfMessage);
1422:            }
1423:
1424:            /**
1425:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueStreamMessageNotAcknowledged(int, int)}
1426:             */
1427:            protected void verifyCreatedQueueStreamMessageNotAcknowledged(
1428:                    int indexOfSession, int indexOfMessage) {
1429:                jmsTestModule.verifyCreatedQueueStreamMessageNotAcknowledged(
1430:                        indexOfSession, indexOfMessage);
1431:            }
1432:
1433:            /**
1434:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueObjectMessageAcknowledged(int, int)}
1435:             */
1436:            protected void verifyCreatedQueueObjectMessageAcknowledged(
1437:                    int indexOfSession, int indexOfMessage) {
1438:                jmsTestModule.verifyCreatedQueueObjectMessageAcknowledged(
1439:                        indexOfSession, indexOfMessage);
1440:            }
1441:
1442:            /**
1443:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedQueueObjectMessageNotAcknowledged(int, int)}
1444:             */
1445:            protected void verifyCreatedQueueObjectMessageNotAcknowledged(
1446:                    int indexOfSession, int indexOfMessage) {
1447:                jmsTestModule.verifyCreatedQueueObjectMessageNotAcknowledged(
1448:                        indexOfSession, indexOfMessage);
1449:            }
1450:
1451:            /**
1452:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCurrentTopicMessageEquals(int, int, int, MockMessage)}
1453:             */
1454:            protected void verifyCurrentTopicMessageEquals(int indexOfSession,
1455:                    int indexOfTopic, int indexOfSourceMessage,
1456:                    MockMessage targetMessage) {
1457:                jmsTestModule.verifyCurrentTopicMessageEquals(indexOfSession,
1458:                        indexOfTopic, indexOfSourceMessage, targetMessage);
1459:            }
1460:
1461:            /**
1462:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCurrentTopicMessageEquals(String, int, MockMessage)}
1463:             */
1464:            protected void verifyCurrentTopicMessageEquals(String nameOfTopic,
1465:                    int indexOfSourceMessage, MockMessage targetMessage) {
1466:                jmsTestModule.verifyCurrentTopicMessageEquals(nameOfTopic,
1467:                        indexOfSourceMessage, targetMessage);
1468:            }
1469:
1470:            /**
1471:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedTopicMessageEquals(String, int, MockMessage)}
1472:             */
1473:            protected void verifyReceivedTopicMessageEquals(String nameOfTopic,
1474:                    int indexOfSourceMessage, MockMessage targetMessage) {
1475:                jmsTestModule.verifyReceivedTopicMessageEquals(nameOfTopic,
1476:                        indexOfSourceMessage, targetMessage);
1477:            }
1478:
1479:            /**
1480:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedTopicMessageEquals(int, int, int, MockMessage)}
1481:             */
1482:            protected void verifyReceivedTopicMessageEquals(int indexOfSession,
1483:                    int indexOfTopic, int indexOfSourceMessage,
1484:                    MockMessage targetMessage) {
1485:                jmsTestModule.verifyReceivedTopicMessageEquals(indexOfSession,
1486:                        indexOfTopic, indexOfSourceMessage, targetMessage);
1487:            }
1488:
1489:            /**
1490:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCurrentTopicMessages(int, int, int)}
1491:             */
1492:            protected void verifyNumberOfCurrentTopicMessages(
1493:                    int indexOfSession, int indexOfTopic, int numberOfMessages) {
1494:                jmsTestModule.verifyNumberOfCurrentTopicMessages(
1495:                        indexOfSession, indexOfTopic, numberOfMessages);
1496:            }
1497:
1498:            /**
1499:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCurrentTopicMessages(String, int)}
1500:             */
1501:            protected void verifyNumberOfCurrentTopicMessages(
1502:                    String nameOfTopic, int numberOfMessages) {
1503:                jmsTestModule.verifyNumberOfCurrentTopicMessages(nameOfTopic,
1504:                        numberOfMessages);
1505:            }
1506:
1507:            /**
1508:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfReceivedTopicMessages(int, int, int)}
1509:             */
1510:            protected void verifyNumberOfReceivedTopicMessages(
1511:                    int indexOfSession, int indexOfTopic, int numberOfMessages) {
1512:                jmsTestModule.verifyNumberOfReceivedTopicMessages(
1513:                        indexOfSession, indexOfTopic, numberOfMessages);
1514:            }
1515:
1516:            /**
1517:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfReceivedTopicMessages(String, int)}
1518:             */
1519:            protected void verifyNumberOfReceivedTopicMessages(
1520:                    String nameOfTopic, int numberOfMessages) {
1521:                jmsTestModule.verifyNumberOfReceivedTopicMessages(nameOfTopic,
1522:                        numberOfMessages);
1523:            }
1524:
1525:            /**
1526:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllReceivedTopicMessagesAcknowledged(String)}
1527:             */
1528:            protected void verifyAllReceivedTopicMessagesAcknowledged(
1529:                    String nameOfTopic) {
1530:                jmsTestModule
1531:                        .verifyAllReceivedTopicMessagesAcknowledged(nameOfTopic);
1532:            }
1533:
1534:            /**
1535:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyAllReceivedTopicMessagesAcknowledged(int, int)}
1536:             */
1537:            protected void verifyAllReceivedTopicMessagesAcknowledged(
1538:                    int indexOfSession, int indexOfTopic) {
1539:                jmsTestModule.verifyAllReceivedTopicMessagesAcknowledged(
1540:                        indexOfSession, indexOfTopic);
1541:            }
1542:
1543:            /**
1544:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedTopicMessageAcknowledged(String, int)}
1545:             */
1546:            protected void verifyReceivedTopicMessageAcknowledged(
1547:                    String nameOfTopic, int indexOfMessage) {
1548:                jmsTestModule.verifyReceivedTopicMessageAcknowledged(
1549:                        nameOfTopic, indexOfMessage);
1550:            }
1551:
1552:            /**
1553:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedTopicMessageAcknowledged(int, int, int)}
1554:             */
1555:            protected void verifyReceivedTopicMessageAcknowledged(
1556:                    int indexOfSession, int indexOfTopic, int indexOfMessage) {
1557:                jmsTestModule.verifyReceivedTopicMessageAcknowledged(
1558:                        indexOfSession, indexOfTopic, indexOfMessage);
1559:            }
1560:
1561:            /**
1562:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedTopicMessageNotAcknowledged(int, int, int)}
1563:             */
1564:            protected void verifyReceivedTopicMessageNotAcknowledged(
1565:                    int indexOfSession, int indexOfTopic, int indexOfMessage) {
1566:                jmsTestModule.verifyReceivedTopicMessageNotAcknowledged(
1567:                        indexOfSession, indexOfTopic, indexOfMessage);
1568:            }
1569:
1570:            /**
1571:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyReceivedTopicMessageNotAcknowledged(String, int)}
1572:             */
1573:            protected void verifyReceivedTopicMessageNotAcknowledged(
1574:                    String nameOfTopic, int indexOfMessage) {
1575:                jmsTestModule.verifyReceivedTopicMessageNotAcknowledged(
1576:                        nameOfTopic, indexOfMessage);
1577:            }
1578:
1579:            /**
1580:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedTopicMessages(int, int)}
1581:             */
1582:            protected void verifyNumberOfCreatedTopicMessages(
1583:                    int indexOfSession, int number) {
1584:                jmsTestModule.verifyNumberOfCreatedTopicMessages(
1585:                        indexOfSession, number);
1586:            }
1587:
1588:            /**
1589:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedTopicBytesMessages(int, int)}
1590:             */
1591:            protected void verifyNumberOfCreatedTopicBytesMessages(
1592:                    int indexOfSession, int number) {
1593:                jmsTestModule.verifyNumberOfCreatedTopicBytesMessages(
1594:                        indexOfSession, number);
1595:            }
1596:
1597:            /**
1598:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedTopicMapMessages(int, int)}
1599:             */
1600:            protected void verifyNumberOfCreatedTopicMapMessages(
1601:                    int indexOfSession, int number) {
1602:                jmsTestModule.verifyNumberOfCreatedTopicMapMessages(
1603:                        indexOfSession, number);
1604:            }
1605:
1606:            /**
1607:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedTopicTextMessages(int, int)}
1608:             */
1609:            protected void verifyNumberOfCreatedTopicTextMessages(
1610:                    int indexOfSession, int number) {
1611:                jmsTestModule.verifyNumberOfCreatedTopicTextMessages(
1612:                        indexOfSession, number);
1613:            }
1614:
1615:            /**
1616:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedTopicStreamMessages(int, int)}
1617:             */
1618:            protected void verifyNumberOfCreatedTopicStreamMessages(
1619:                    int indexOfSession, int number) {
1620:                jmsTestModule.verifyNumberOfCreatedTopicStreamMessages(
1621:                        indexOfSession, number);
1622:            }
1623:
1624:            /**
1625:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedTopicObjectMessages(int, int)}
1626:             */
1627:            protected void verifyNumberOfCreatedTopicObjectMessages(
1628:                    int indexOfSession, int number) {
1629:                jmsTestModule.verifyNumberOfCreatedTopicObjectMessages(
1630:                        indexOfSession, number);
1631:            }
1632:
1633:            /**
1634:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicMessageAcknowledged(int, int)}
1635:             */
1636:            protected void verifyCreatedTopicMessageAcknowledged(
1637:                    int indexOfSession, int indexOfMessage) {
1638:                jmsTestModule.verifyCreatedTopicMessageAcknowledged(
1639:                        indexOfSession, indexOfMessage);
1640:            }
1641:
1642:            /**
1643:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicMessageNotAcknowledged(int, int)}
1644:             */
1645:            protected void verifyCreatedTopicMessageNotAcknowledged(
1646:                    int indexOfSession, int indexOfMessage) {
1647:                jmsTestModule.verifyCreatedTopicMessageNotAcknowledged(
1648:                        indexOfSession, indexOfMessage);
1649:            }
1650:
1651:            /**
1652:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicBytesMessageAcknowledged(int, int)}
1653:             */
1654:            protected void verifyCreatedTopicBytesMessageAcknowledged(
1655:                    int indexOfSession, int indexOfMessage) {
1656:                jmsTestModule.verifyCreatedTopicBytesMessageAcknowledged(
1657:                        indexOfSession, indexOfMessage);
1658:            }
1659:
1660:            /**
1661:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicBytesMessageNotAcknowledged(int, int)}
1662:             */
1663:            protected void verifyCreatedTopicBytesMessageNotAcknowledged(
1664:                    int indexOfSession, int indexOfMessage) {
1665:                jmsTestModule.verifyCreatedTopicBytesMessageNotAcknowledged(
1666:                        indexOfSession, indexOfMessage);
1667:            }
1668:
1669:            /**
1670:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicMapMessageAcknowledged(int, int)}
1671:             */
1672:            protected void verifyCreatedTopicMapMessageAcknowledged(
1673:                    int indexOfSession, int indexOfMessage) {
1674:                jmsTestModule.verifyCreatedTopicMapMessageAcknowledged(
1675:                        indexOfSession, indexOfMessage);
1676:            }
1677:
1678:            /**
1679:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicMapMessageNotAcknowledged(int, int)}
1680:             */
1681:            protected void verifyCreatedTopicMapMessageNotAcknowledged(
1682:                    int indexOfSession, int indexOfMessage) {
1683:                jmsTestModule.verifyCreatedTopicMapMessageNotAcknowledged(
1684:                        indexOfSession, indexOfMessage);
1685:            }
1686:
1687:            /**
1688:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicTextMessageAcknowledged(int, int)}
1689:             */
1690:            protected void verifyCreatedTopicTextMessageAcknowledged(
1691:                    int indexOfSession, int indexOfMessage) {
1692:                jmsTestModule.verifyCreatedTopicTextMessageAcknowledged(
1693:                        indexOfSession, indexOfMessage);
1694:            }
1695:
1696:            /**
1697:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicTextMessageNotAcknowledged(int, int)}
1698:             */
1699:            protected void verifyCreatedTopicTextMessageNotAcknowledged(
1700:                    int indexOfSession, int indexOfMessage) {
1701:                jmsTestModule.verifyCreatedTopicTextMessageNotAcknowledged(
1702:                        indexOfSession, indexOfMessage);
1703:            }
1704:
1705:            /**
1706:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicStreamMessageAcknowledged(int, int)}
1707:             */
1708:            protected void verifyCreatedTopicStreamMessageAcknowledged(
1709:                    int indexOfSession, int indexOfMessage) {
1710:                jmsTestModule.verifyCreatedTopicStreamMessageAcknowledged(
1711:                        indexOfSession, indexOfMessage);
1712:            }
1713:
1714:            /**
1715:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicStreamMessageNotAcknowledged(int, int)}
1716:             */
1717:            protected void verifyCreatedTopicStreamMessageNotAcknowledged(
1718:                    int indexOfSession, int indexOfMessage) {
1719:                jmsTestModule.verifyCreatedTopicStreamMessageNotAcknowledged(
1720:                        indexOfSession, indexOfMessage);
1721:            }
1722:
1723:            /**
1724:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicObjectMessageAcknowledged(int, int)}
1725:             */
1726:            protected void verifyCreatedTopicObjectMessageAcknowledged(
1727:                    int indexOfSession, int indexOfMessage) {
1728:                jmsTestModule.verifyCreatedTopicObjectMessageAcknowledged(
1729:                        indexOfSession, indexOfMessage);
1730:            }
1731:
1732:            /**
1733:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTopicObjectMessageNotAcknowledged(int, int)}
1734:             */
1735:            protected void verifyCreatedTopicObjectMessageNotAcknowledged(
1736:                    int indexOfSession, int indexOfMessage) {
1737:                jmsTestModule.verifyCreatedTopicObjectMessageNotAcknowledged(
1738:                        indexOfSession, indexOfMessage);
1739:            }
1740:
1741:            /**
1742:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedMessages(int, int)}
1743:             */
1744:            protected void verifyNumberOfCreatedMessages(int indexOfSession,
1745:                    int number) {
1746:                jmsTestModule.verifyNumberOfCreatedMessages(indexOfSession,
1747:                        number);
1748:            }
1749:
1750:            /**
1751:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedBytesMessages(int, int)}
1752:             */
1753:            protected void verifyNumberOfCreatedBytesMessages(
1754:                    int indexOfSession, int number) {
1755:                jmsTestModule.verifyNumberOfCreatedBytesMessages(
1756:                        indexOfSession, number);
1757:            }
1758:
1759:            /**
1760:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedMapMessages(int, int)}
1761:             */
1762:            protected void verifyNumberOfCreatedMapMessages(int indexOfSession,
1763:                    int number) {
1764:                jmsTestModule.verifyNumberOfCreatedMapMessages(indexOfSession,
1765:                        number);
1766:            }
1767:
1768:            /**
1769:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedTextMessages(int, int)}
1770:             */
1771:            protected void verifyNumberOfCreatedTextMessages(
1772:                    int indexOfSession, int number) {
1773:                jmsTestModule.verifyNumberOfCreatedTextMessages(indexOfSession,
1774:                        number);
1775:            }
1776:
1777:            /**
1778:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedStreamMessages(int, int)}
1779:             */
1780:            protected void verifyNumberOfCreatedStreamMessages(
1781:                    int indexOfSession, int number) {
1782:                jmsTestModule.verifyNumberOfCreatedStreamMessages(
1783:                        indexOfSession, number);
1784:            }
1785:
1786:            /**
1787:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyNumberOfCreatedObjectMessages(int, int)}
1788:             */
1789:            protected void verifyNumberOfCreatedObjectMessages(
1790:                    int indexOfSession, int number) {
1791:                jmsTestModule.verifyNumberOfCreatedObjectMessages(
1792:                        indexOfSession, number);
1793:            }
1794:
1795:            /**
1796:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedMessageAcknowledged(int, int)}
1797:             */
1798:            protected void verifyCreatedMessageAcknowledged(int indexOfSession,
1799:                    int indexOfMessage) {
1800:                jmsTestModule.verifyCreatedMessageAcknowledged(indexOfSession,
1801:                        indexOfMessage);
1802:            }
1803:
1804:            /**
1805:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedMessageNotAcknowledged(int, int)}
1806:             */
1807:            protected void verifyCreatedMessageNotAcknowledged(
1808:                    int indexOfSession, int indexOfMessage) {
1809:                jmsTestModule.verifyCreatedMessageNotAcknowledged(
1810:                        indexOfSession, indexOfMessage);
1811:            }
1812:
1813:            /**
1814:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedBytesMessageAcknowledged(int, int)}
1815:             */
1816:            protected void verifyCreatedBytesMessageAcknowledged(
1817:                    int indexOfSession, int indexOfMessage) {
1818:                jmsTestModule.verifyCreatedBytesMessageAcknowledged(
1819:                        indexOfSession, indexOfMessage);
1820:            }
1821:
1822:            /**
1823:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedBytesMessageNotAcknowledged(int, int)}
1824:             */
1825:            protected void verifyCreatedBytesMessageNotAcknowledged(
1826:                    int indexOfSession, int indexOfMessage) {
1827:                jmsTestModule.verifyCreatedBytesMessageNotAcknowledged(
1828:                        indexOfSession, indexOfMessage);
1829:            }
1830:
1831:            /**
1832:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedMapMessageAcknowledged(int, int)}
1833:             */
1834:            protected void verifyCreatedMapMessageAcknowledged(
1835:                    int indexOfSession, int indexOfMessage) {
1836:                jmsTestModule.verifyCreatedMapMessageAcknowledged(
1837:                        indexOfSession, indexOfMessage);
1838:            }
1839:
1840:            /**
1841:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedMapMessageNotAcknowledged(int, int)}
1842:             */
1843:            protected void verifyCreatedMapMessageNotAcknowledged(
1844:                    int indexOfSession, int indexOfMessage) {
1845:                jmsTestModule.verifyCreatedMapMessageNotAcknowledged(
1846:                        indexOfSession, indexOfMessage);
1847:            }
1848:
1849:            /**
1850:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTextMessageAcknowledged(int, int)}
1851:             */
1852:            protected void verifyCreatedTextMessageAcknowledged(
1853:                    int indexOfSession, int indexOfMessage) {
1854:                jmsTestModule.verifyCreatedTextMessageAcknowledged(
1855:                        indexOfSession, indexOfMessage);
1856:            }
1857:
1858:            /**
1859:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedTextMessageNotAcknowledged(int, int)}
1860:             */
1861:            protected void verifyCreatedTextMessageNotAcknowledged(
1862:                    int indexOfSession, int indexOfMessage) {
1863:                jmsTestModule.verifyCreatedTextMessageNotAcknowledged(
1864:                        indexOfSession, indexOfMessage);
1865:            }
1866:
1867:            /**
1868:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedStreamMessageAcknowledged(int, int)}
1869:             */
1870:            protected void verifyCreatedStreamMessageAcknowledged(
1871:                    int indexOfSession, int indexOfMessage) {
1872:                jmsTestModule.verifyCreatedStreamMessageAcknowledged(
1873:                        indexOfSession, indexOfMessage);
1874:            }
1875:
1876:            /**
1877:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedStreamMessageNotAcknowledged(int, int)}
1878:             */
1879:            protected void verifyCreatedStreamMessageNotAcknowledged(
1880:                    int indexOfSession, int indexOfMessage) {
1881:                jmsTestModule.verifyCreatedStreamMessageNotAcknowledged(
1882:                        indexOfSession, indexOfMessage);
1883:            }
1884:
1885:            /**
1886:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedObjectMessageAcknowledged(int, int)}
1887:             */
1888:            protected void verifyCreatedObjectMessageAcknowledged(
1889:                    int indexOfSession, int indexOfMessage) {
1890:                jmsTestModule.verifyCreatedObjectMessageAcknowledged(
1891:                        indexOfSession, indexOfMessage);
1892:            }
1893:
1894:            /**
1895:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#verifyCreatedObjectMessageNotAcknowledged(int, int)}
1896:             */
1897:            protected void verifyCreatedObjectMessageNotAcknowledged(
1898:                    int indexOfSession, int indexOfMessage) {
1899:                jmsTestModule.verifyCreatedObjectMessageNotAcknowledged(
1900:                        indexOfSession, indexOfMessage);
1901:            }
1902:
1903:            /**
1904:             * Delegates to {@link com.mockrunner.jms.JMSTestModule#getQueue(String)}
1905:             */
1906:            protected MockQueue getQueue(String name) {
1907:                return jmsTestModule.getQueue(name);
1908:            }
1909:        }
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.