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: }
|