0001: package com.mockrunner.jdbc;
0002:
0003: import java.sql.CallableStatement;
0004: import java.sql.PreparedStatement;
0005: import java.util.List;
0006: import java.util.Map;
0007:
0008: import junit.framework.TestCase;
0009:
0010: import com.mockrunner.mock.jdbc.JDBCMockObjectFactory;
0011: import com.mockrunner.mock.jdbc.MockCallableStatement;
0012: import com.mockrunner.mock.jdbc.MockPreparedStatement;
0013: import com.mockrunner.mock.jdbc.MockResultSet; //import com.mockrunner.mock.jdbc.MockSavepoint;
0014: import com.mockrunner.mock.jdbc.MockStatement;
0015:
0016: /**
0017: * Delegator for {@link com.mockrunner.jdbc.JDBCTestModule}. You can
0018: * subclass this adapter or use {@link com.mockrunner.jdbc.JDBCTestModule}
0019: * directly (so your test case can use another base class).
0020: * This basic adapter can be used if you don't need any other modules. It
0021: * does not extend {@link com.mockrunner.base.BaseTestCase}. If you want
0022: * to use several modules in conjunction, consider subclassing
0023: * {@link com.mockrunner.jdbc.JDBCTestCaseAdapter}.
0024: * <b>This class is generated from the {@link com.mockrunner.jdbc.JDBCTestModule}
0025: * and should not be edited directly</b>.
0026: */
0027: public abstract class BasicJDBCTestCaseAdapter extends TestCase {
0028: private JDBCTestModule jdbcTestModule;
0029: private JDBCMockObjectFactory jdbcMockObjectFactory;
0030:
0031: public BasicJDBCTestCaseAdapter() {
0032:
0033: }
0034:
0035: public BasicJDBCTestCaseAdapter(String name) {
0036: super (name);
0037: }
0038:
0039: protected void tearDown() throws Exception {
0040: super .tearDown();
0041: if (null != jdbcMockObjectFactory) {
0042: jdbcMockObjectFactory.restoreDrivers();
0043: }
0044: jdbcTestModule = null;
0045: jdbcMockObjectFactory = null;
0046: }
0047:
0048: /**
0049: * Creates the {@link com.mockrunner.jdbc.JDBCTestModule}. If you
0050: * overwrite this method, you must call <code>super.setUp()</code>.
0051: */
0052: protected void setUp() throws Exception {
0053: super .setUp();
0054: jdbcTestModule = createJDBCTestModule(getJDBCMockObjectFactory());
0055: }
0056:
0057: /**
0058: * Creates a {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
0059: * @return the created {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}
0060: */
0061: protected JDBCMockObjectFactory createJDBCMockObjectFactory() {
0062: return new JDBCMockObjectFactory();
0063: }
0064:
0065: /**
0066: * Gets the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
0067: * @return the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}
0068: */
0069: protected JDBCMockObjectFactory getJDBCMockObjectFactory() {
0070: synchronized (JDBCMockObjectFactory.class) {
0071: if (jdbcMockObjectFactory == null) {
0072: jdbcMockObjectFactory = createJDBCMockObjectFactory();
0073: }
0074: }
0075: return jdbcMockObjectFactory;
0076: }
0077:
0078: /**
0079: * Sets the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
0080: * @param jdbcMockObjectFactory the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}
0081: */
0082: protected void setJDBCMockObjectFactory(
0083: JDBCMockObjectFactory jdbcMockObjectFactory) {
0084: this .jdbcMockObjectFactory = jdbcMockObjectFactory;
0085: }
0086:
0087: /**
0088: * Creates a {@link com.mockrunner.jdbc.JDBCTestModule} based on the current
0089: * {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
0090: * Same as <code>createJDBCTestModule(getJDBCMockObjectFactory())</code>.
0091: * @return the created {@link com.mockrunner.jdbc.JDBCTestModule}
0092: */
0093: protected JDBCTestModule createJDBCTestModule() {
0094: return new JDBCTestModule(getJDBCMockObjectFactory());
0095: }
0096:
0097: /**
0098: * Creates a {@link com.mockrunner.jdbc.JDBCTestModule} with the specified
0099: * {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
0100: * @return the created {@link com.mockrunner.jdbc.JDBCTestModule}
0101: */
0102: protected JDBCTestModule createJDBCTestModule(
0103: JDBCMockObjectFactory mockFactory) {
0104: return new JDBCTestModule(mockFactory);
0105: }
0106:
0107: /**
0108: * Gets the {@link com.mockrunner.jdbc.JDBCTestModule}.
0109: * @return the {@link com.mockrunner.jdbc.JDBCTestModule}
0110: */
0111: protected JDBCTestModule getJDBCTestModule() {
0112: return jdbcTestModule;
0113: }
0114:
0115: /**
0116: * Sets the {@link com.mockrunner.jdbc.JDBCTestModule}.
0117: * @param jdbcTestModule the {@link com.mockrunner.jdbc.JDBCTestModule}
0118: */
0119: protected void setJDBCTestModule(JDBCTestModule jdbcTestModule) {
0120: this .jdbcTestModule = jdbcTestModule;
0121: }
0122:
0123: /**
0124: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#setCaseSensitive(boolean)}
0125: */
0126: protected void setCaseSensitive(boolean caseSensitive) {
0127: jdbcTestModule.setCaseSensitive(caseSensitive);
0128: }
0129:
0130: /**
0131: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCommitted}
0132: */
0133: protected void verifyCommitted() {
0134: jdbcTestModule.verifyCommitted();
0135: }
0136:
0137: /**
0138: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNotCommitted}
0139: */
0140: protected void verifyNotCommitted() {
0141: jdbcTestModule.verifyNotCommitted();
0142: }
0143:
0144: /**
0145: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyRolledBack}
0146: */
0147: protected void verifyRolledBack() {
0148: jdbcTestModule.verifyRolledBack();
0149: }
0150:
0151: /**
0152: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNotRolledBack}
0153: */
0154: protected void verifyNotRolledBack() {
0155: jdbcTestModule.verifyNotRolledBack();
0156: }
0157:
0158: /**
0159: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#setExactMatch(boolean)}
0160: */
0161: protected void setExactMatch(boolean exactMatch) {
0162: jdbcTestModule.setExactMatch(exactMatch);
0163: }
0164:
0165: /**
0166: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#setUseRegularExpressions(boolean)}
0167: */
0168: protected void setUseRegularExpressions(
0169: boolean useRegularExpressions) {
0170: jdbcTestModule.setUseRegularExpressions(useRegularExpressions);
0171: }
0172:
0173: /**
0174: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getStatementResultSetHandler}
0175: */
0176: protected StatementResultSetHandler getStatementResultSetHandler() {
0177: return jdbcTestModule.getStatementResultSetHandler();
0178: }
0179:
0180: /**
0181: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementResultSetHandler}
0182: */
0183: protected PreparedStatementResultSetHandler getPreparedStatementResultSetHandler() {
0184: return jdbcTestModule.getPreparedStatementResultSetHandler();
0185: }
0186:
0187: /**
0188: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementResultSetHandler}
0189: */
0190: protected CallableStatementResultSetHandler getCallableStatementResultSetHandler() {
0191: return jdbcTestModule.getCallableStatementResultSetHandler();
0192: }
0193:
0194: /**
0195: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getStatement(int)}
0196: */
0197: protected MockStatement getStatement(int index) {
0198: return jdbcTestModule.getStatement(index);
0199: }
0200:
0201: /**
0202: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getStatements}
0203: */
0204: protected List getStatements() {
0205: return jdbcTestModule.getStatements();
0206: }
0207:
0208: /**
0209: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getExecutedSQLStatements}
0210: */
0211: protected List getExecutedSQLStatements() {
0212: return jdbcTestModule.getExecutedSQLStatements();
0213: }
0214:
0215: /**
0216: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getExecutedSQLStatementParameter}
0217: * @deprecated
0218: */
0219: protected Map getExecutedSQLStatementParameter() {
0220: return jdbcTestModule.getExecutedSQLStatementParameter();
0221: }
0222:
0223: /**
0224: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getExecutedSQLStatementParameterMap}
0225: */
0226: protected Map getExecutedSQLStatementParameterMap() {
0227: return jdbcTestModule.getExecutedSQLStatementParameterMap();
0228: }
0229:
0230: /**
0231: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getExecutedSQLStatementParameterSets(String)}
0232: */
0233: protected ParameterSets getExecutedSQLStatementParameterSets(
0234: String sql) {
0235: return jdbcTestModule.getExecutedSQLStatementParameterSets(sql);
0236: }
0237:
0238: /**
0239: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getReturnedResultSet(String)}
0240: */
0241: protected MockResultSet getReturnedResultSet(String id) {
0242: return jdbcTestModule.getReturnedResultSet(id);
0243: }
0244:
0245: /**
0246: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getReturnedResultSets(String)}
0247: */
0248: protected List getReturnedResultSets(String id) {
0249: return jdbcTestModule.getReturnedResultSets(id);
0250: }
0251:
0252: /**
0253: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getReturnedResultSets}
0254: */
0255: protected List getReturnedResultSets() {
0256: return jdbcTestModule.getReturnedResultSets();
0257: }
0258:
0259: /**
0260: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatement(String)}
0261: */
0262: protected MockPreparedStatement getPreparedStatement(String sql) {
0263: return jdbcTestModule.getPreparedStatement(sql);
0264: }
0265:
0266: /**
0267: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatement(int)}
0268: */
0269: protected MockPreparedStatement getPreparedStatement(int index) {
0270: return jdbcTestModule.getPreparedStatement(index);
0271: }
0272:
0273: /**
0274: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatements(String)}
0275: */
0276: protected List getPreparedStatements(String sql) {
0277: return jdbcTestModule.getPreparedStatements(sql);
0278: }
0279:
0280: /**
0281: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatements}
0282: */
0283: protected List getPreparedStatements() {
0284: return jdbcTestModule.getPreparedStatements();
0285: }
0286:
0287: /**
0288: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatement(String)}
0289: */
0290: protected MockCallableStatement getCallableStatement(String sql) {
0291: return jdbcTestModule.getCallableStatement(sql);
0292: }
0293:
0294: /**
0295: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatement(int)}
0296: */
0297: protected MockCallableStatement getCallableStatement(int index) {
0298: return jdbcTestModule.getCallableStatement(index);
0299: }
0300:
0301: /**
0302: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatements(String)}
0303: */
0304: protected List getCallableStatements(String sql) {
0305: return jdbcTestModule.getCallableStatements(sql);
0306: }
0307:
0308: /**
0309: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatements}
0310: */
0311: protected List getCallableStatements() {
0312: return jdbcTestModule.getCallableStatements();
0313: }
0314:
0315: /**
0316: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementParameter(String, int)}
0317: */
0318: protected Object getPreparedStatementParameter(String sql,
0319: int indexOfParameter) {
0320: return jdbcTestModule.getPreparedStatementParameter(sql,
0321: indexOfParameter);
0322: }
0323:
0324: /**
0325: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementParameter(int, int)}
0326: */
0327: protected Object getPreparedStatementParameter(
0328: int indexOfStatement, int indexOfParameter) {
0329: return jdbcTestModule.getPreparedStatementParameter(
0330: indexOfStatement, indexOfParameter);
0331: }
0332:
0333: /**
0334: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementParameter(PreparedStatement, int)}
0335: */
0336: protected Object getPreparedStatementParameter(
0337: PreparedStatement statement, int indexOfParameter) {
0338: return jdbcTestModule.getPreparedStatementParameter(statement,
0339: indexOfParameter);
0340: }
0341:
0342: /**
0343: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(String, String)}
0344: */
0345: protected Object getCallableStatementParameter(String sql,
0346: String nameOfParameter) {
0347: return jdbcTestModule.getCallableStatementParameter(sql,
0348: nameOfParameter);
0349: }
0350:
0351: /**
0352: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(int, String)}
0353: */
0354: protected Object getCallableStatementParameter(
0355: int indexOfStatement, String nameOfParameter) {
0356: return jdbcTestModule.getCallableStatementParameter(
0357: indexOfStatement, nameOfParameter);
0358: }
0359:
0360: /**
0361: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(CallableStatement, String)}
0362: */
0363: protected Object getCallableStatementParameter(
0364: CallableStatement statement, String nameOfParameter) {
0365: return jdbcTestModule.getCallableStatementParameter(statement,
0366: nameOfParameter);
0367: }
0368:
0369: /**
0370: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(String, int)}
0371: */
0372: protected Object getCallableStatementParameter(String sql,
0373: int indexOfParameter) {
0374: return jdbcTestModule.getCallableStatementParameter(sql,
0375: indexOfParameter);
0376: }
0377:
0378: /**
0379: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(CallableStatement, int)}
0380: */
0381: protected Object getCallableStatementParameter(
0382: CallableStatement statement, int indexOfParameter) {
0383: return jdbcTestModule.getCallableStatementParameter(statement,
0384: indexOfParameter);
0385: }
0386:
0387: /**
0388: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(int, int)}
0389: */
0390: protected Object getCallableStatementParameter(
0391: int indexOfStatement, int indexOfParameter) {
0392: return jdbcTestModule.getCallableStatementParameter(
0393: indexOfStatement, indexOfParameter);
0394: }
0395:
0396: /**
0397: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getSavepoints}
0398: */
0399: /*protected List getSavepoints()
0400: {
0401: return jdbcTestModule.getSavepoints();
0402: }*/
0403:
0404: /**
0405: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getSavepoint(int)}
0406: */
0407: /*protected MockSavepoint getSavepoint(int index)
0408: {
0409: return jdbcTestModule.getSavepoint(index);
0410: }*/
0411:
0412: /**
0413: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getSavepoint(String)}
0414: */
0415: /*protected MockSavepoint getSavepoint(String name)
0416: {
0417: return jdbcTestModule.getSavepoint(name);
0418: }*/
0419:
0420: /**
0421: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementExecuted(String)}
0422: */
0423: protected void verifySQLStatementExecuted(String sql) {
0424: jdbcTestModule.verifySQLStatementExecuted(sql);
0425: }
0426:
0427: /**
0428: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementNotExecuted(String)}
0429: */
0430: protected void verifySQLStatementNotExecuted(String sql) {
0431: jdbcTestModule.verifySQLStatementNotExecuted(sql);
0432: }
0433:
0434: /**
0435: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameterNumber(String, int, int)}
0436: */
0437: protected void verifySQLStatementParameterNumber(String sql,
0438: int indexOfParameterSet, int number) {
0439: jdbcTestModule.verifySQLStatementParameterNumber(sql,
0440: indexOfParameterSet, number);
0441: }
0442:
0443: /**
0444: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameter(String, int, String, Object)}
0445: */
0446: protected void verifySQLStatementParameter(String sql,
0447: int indexOfParameterSet, String nameOfParameter,
0448: Object expectedParameter) {
0449: jdbcTestModule
0450: .verifySQLStatementParameter(sql, indexOfParameterSet,
0451: nameOfParameter, expectedParameter);
0452: }
0453:
0454: /**
0455: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameter(String, int, int, Object)}
0456: */
0457: protected void verifySQLStatementParameter(String sql,
0458: int indexOfParameterSet, int indexOfParameter,
0459: Object expectedParameter) {
0460: jdbcTestModule.verifySQLStatementParameter(sql,
0461: indexOfParameterSet, indexOfParameter,
0462: expectedParameter);
0463: }
0464:
0465: /**
0466: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameter(String, int, Map)}
0467: */
0468: protected void verifySQLStatementParameter(String sql,
0469: int indexOfParameterSet, Map parameterMap) {
0470: jdbcTestModule.verifySQLStatementParameter(sql,
0471: indexOfParameterSet, parameterMap);
0472: }
0473:
0474: /**
0475: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyConnectionClosed}
0476: */
0477: protected void verifyConnectionClosed() {
0478: jdbcTestModule.verifyConnectionClosed();
0479: }
0480:
0481: /**
0482: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyAllStatementsClosed}
0483: */
0484: protected void verifyAllStatementsClosed() {
0485: jdbcTestModule.verifyAllStatementsClosed();
0486: }
0487:
0488: /**
0489: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetClosed(String)}
0490: */
0491: protected void verifyResultSetClosed(String id) {
0492: jdbcTestModule.verifyResultSetClosed(id);
0493: }
0494:
0495: /**
0496: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowInserted(MockResultSet, int)}
0497: */
0498: protected void verifyResultSetRowInserted(MockResultSet resultSet,
0499: int number) {
0500: jdbcTestModule.verifyResultSetRowInserted(resultSet, number);
0501: }
0502:
0503: /**
0504: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowInserted(String, int)}
0505: */
0506: protected void verifyResultSetRowInserted(String id, int number) {
0507: jdbcTestModule.verifyResultSetRowInserted(id, number);
0508: }
0509:
0510: /**
0511: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotInserted(MockResultSet, int)}
0512: */
0513: protected void verifyResultSetRowNotInserted(
0514: MockResultSet resultSet, int number) {
0515: jdbcTestModule.verifyResultSetRowNotInserted(resultSet, number);
0516: }
0517:
0518: /**
0519: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotInserted(String, int)}
0520: */
0521: protected void verifyResultSetRowNotInserted(String id, int number) {
0522: jdbcTestModule.verifyResultSetRowNotInserted(id, number);
0523: }
0524:
0525: /**
0526: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowUpdated(MockResultSet, int)}
0527: */
0528: protected void verifyResultSetRowUpdated(MockResultSet resultSet,
0529: int number) {
0530: jdbcTestModule.verifyResultSetRowUpdated(resultSet, number);
0531: }
0532:
0533: /**
0534: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowUpdated(String, int)}
0535: */
0536: protected void verifyResultSetRowUpdated(String id, int number) {
0537: jdbcTestModule.verifyResultSetRowUpdated(id, number);
0538: }
0539:
0540: /**
0541: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotUpdated(String, int)}
0542: */
0543: protected void verifyResultSetRowNotUpdated(String id, int number) {
0544: jdbcTestModule.verifyResultSetRowNotUpdated(id, number);
0545: }
0546:
0547: /**
0548: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotUpdated(MockResultSet, int)}
0549: */
0550: protected void verifyResultSetRowNotUpdated(
0551: MockResultSet resultSet, int number) {
0552: jdbcTestModule.verifyResultSetRowNotUpdated(resultSet, number);
0553: }
0554:
0555: /**
0556: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowDeleted(MockResultSet, int)}
0557: */
0558: protected void verifyResultSetRowDeleted(MockResultSet resultSet,
0559: int number) {
0560: jdbcTestModule.verifyResultSetRowDeleted(resultSet, number);
0561: }
0562:
0563: /**
0564: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowDeleted(String, int)}
0565: */
0566: protected void verifyResultSetRowDeleted(String id, int number) {
0567: jdbcTestModule.verifyResultSetRowDeleted(id, number);
0568: }
0569:
0570: /**
0571: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotDeleted(String, int)}
0572: */
0573: protected void verifyResultSetRowNotDeleted(String id, int number) {
0574: jdbcTestModule.verifyResultSetRowNotDeleted(id, number);
0575: }
0576:
0577: /**
0578: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotDeleted(MockResultSet, int)}
0579: */
0580: protected void verifyResultSetRowNotDeleted(
0581: MockResultSet resultSet, int number) {
0582: jdbcTestModule.verifyResultSetRowNotDeleted(resultSet, number);
0583: }
0584:
0585: /**
0586: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyAllResultSetsClosed}
0587: */
0588: protected void verifyAllResultSetsClosed() {
0589: jdbcTestModule.verifyAllResultSetsClosed();
0590: }
0591:
0592: /**
0593: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberCommits(int)}
0594: */
0595: protected void verifyNumberCommits(int number) {
0596: jdbcTestModule.verifyNumberCommits(number);
0597: }
0598:
0599: /**
0600: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberRollbacks(int)}
0601: */
0602: protected void verifyNumberRollbacks(int number) {
0603: jdbcTestModule.verifyNumberRollbacks(number);
0604: }
0605:
0606: /**
0607: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberStatements(int)}
0608: */
0609: protected void verifyNumberStatements(int number) {
0610: jdbcTestModule.verifyNumberStatements(number);
0611: }
0612:
0613: /**
0614: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberPreparedStatements(int, String)}
0615: */
0616: protected void verifyNumberPreparedStatements(int number, String sql) {
0617: jdbcTestModule.verifyNumberPreparedStatements(number, sql);
0618: }
0619:
0620: /**
0621: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberPreparedStatements(int)}
0622: */
0623: protected void verifyNumberPreparedStatements(int number) {
0624: jdbcTestModule.verifyNumberPreparedStatements(number);
0625: }
0626:
0627: /**
0628: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberCallableStatements(int, String)}
0629: */
0630: protected void verifyNumberCallableStatements(int number, String sql) {
0631: jdbcTestModule.verifyNumberCallableStatements(number, sql);
0632: }
0633:
0634: /**
0635: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberCallableStatements(int)}
0636: */
0637: protected void verifyNumberCallableStatements(int number) {
0638: jdbcTestModule.verifyNumberCallableStatements(number);
0639: }
0640:
0641: /**
0642: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyStatementClosed(int)}
0643: */
0644: protected void verifyStatementClosed(int index) {
0645: jdbcTestModule.verifyStatementClosed(index);
0646: }
0647:
0648: /**
0649: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementClosed(String)}
0650: */
0651: protected void verifyPreparedStatementClosed(String sql) {
0652: jdbcTestModule.verifyPreparedStatementClosed(sql);
0653: }
0654:
0655: /**
0656: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementClosed(int)}
0657: */
0658: protected void verifyPreparedStatementClosed(int index) {
0659: jdbcTestModule.verifyPreparedStatementClosed(index);
0660: }
0661:
0662: /**
0663: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementClosed(int)}
0664: */
0665: protected void verifyCallableStatementClosed(int index) {
0666: jdbcTestModule.verifyCallableStatementClosed(index);
0667: }
0668:
0669: /**
0670: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementClosed(String)}
0671: */
0672: protected void verifyCallableStatementClosed(String sql) {
0673: jdbcTestModule.verifyCallableStatementClosed(sql);
0674: }
0675:
0676: /**
0677: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(MockResultSet, int, List)}
0678: */
0679: protected void verifyResultSetRow(MockResultSet resultSet,
0680: int number, List rowData) {
0681: jdbcTestModule.verifyResultSetRow(resultSet, number, rowData);
0682: }
0683:
0684: /**
0685: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(MockResultSet, int, Object[])}
0686: */
0687: protected void verifyResultSetRow(MockResultSet resultSet,
0688: int number, Object[] rowData) {
0689: jdbcTestModule.verifyResultSetRow(resultSet, number, rowData);
0690: }
0691:
0692: /**
0693: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(String, int, List)}
0694: */
0695: protected void verifyResultSetRow(String id, int number,
0696: List rowData) {
0697: jdbcTestModule.verifyResultSetRow(id, number, rowData);
0698: }
0699:
0700: /**
0701: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(String, int, Object[])}
0702: */
0703: protected void verifyResultSetRow(String id, int number,
0704: Object[] rowData) {
0705: jdbcTestModule.verifyResultSetRow(id, number, rowData);
0706: }
0707:
0708: /**
0709: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, String, List)}
0710: */
0711: protected void verifyResultSetColumn(String id, String name,
0712: List columnData) {
0713: jdbcTestModule.verifyResultSetColumn(id, name, columnData);
0714: }
0715:
0716: /**
0717: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, int, List)}
0718: */
0719: protected void verifyResultSetColumn(MockResultSet resultSet,
0720: int number, List columnData) {
0721: jdbcTestModule.verifyResultSetColumn(resultSet, number,
0722: columnData);
0723: }
0724:
0725: /**
0726: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, int, Object[])}
0727: */
0728: protected void verifyResultSetColumn(MockResultSet resultSet,
0729: int number, Object[] columnData) {
0730: jdbcTestModule.verifyResultSetColumn(resultSet, number,
0731: columnData);
0732: }
0733:
0734: /**
0735: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, int, List)}
0736: */
0737: protected void verifyResultSetColumn(String id, int number,
0738: List columnData) {
0739: jdbcTestModule.verifyResultSetColumn(id, number, columnData);
0740: }
0741:
0742: /**
0743: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, int, Object[])}
0744: */
0745: protected void verifyResultSetColumn(String id, int number,
0746: Object[] columnData) {
0747: jdbcTestModule.verifyResultSetColumn(id, number, columnData);
0748: }
0749:
0750: /**
0751: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, String, List)}
0752: */
0753: protected void verifyResultSetColumn(MockResultSet resultSet,
0754: String name, List columnData) {
0755: jdbcTestModule.verifyResultSetColumn(resultSet, name,
0756: columnData);
0757: }
0758:
0759: /**
0760: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, String, Object[])}
0761: */
0762: protected void verifyResultSetColumn(MockResultSet resultSet,
0763: String name, Object[] columnData) {
0764: jdbcTestModule.verifyResultSetColumn(resultSet, name,
0765: columnData);
0766: }
0767:
0768: /**
0769: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, String, Object[])}
0770: */
0771: protected void verifyResultSetColumn(String id, String name,
0772: Object[] columnData) {
0773: jdbcTestModule.verifyResultSetColumn(id, name, columnData);
0774: }
0775:
0776: /**
0777: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetEquals(String, MockResultSet)}
0778: */
0779: protected void verifyResultSetEquals(String id, MockResultSet target) {
0780: jdbcTestModule.verifyResultSetEquals(id, target);
0781: }
0782:
0783: /**
0784: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetEquals(MockResultSet, MockResultSet)}
0785: */
0786: protected void verifyResultSetEquals(MockResultSet source,
0787: MockResultSet target) {
0788: jdbcTestModule.verifyResultSetEquals(source, target);
0789: }
0790:
0791: /**
0792: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementPresent(String)}
0793: */
0794: protected void verifyPreparedStatementPresent(String sql) {
0795: jdbcTestModule.verifyPreparedStatementPresent(sql);
0796: }
0797:
0798: /**
0799: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementNotPresent(String)}
0800: */
0801: protected void verifyPreparedStatementNotPresent(String sql) {
0802: jdbcTestModule.verifyPreparedStatementNotPresent(sql);
0803: }
0804:
0805: /**
0806: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementPresent(String)}
0807: */
0808: protected void verifyCallableStatementPresent(String sql) {
0809: jdbcTestModule.verifyCallableStatementPresent(sql);
0810: }
0811:
0812: /**
0813: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementNotPresent(String)}
0814: */
0815: protected void verifyCallableStatementNotPresent(String sql) {
0816: jdbcTestModule.verifyCallableStatementNotPresent(sql);
0817: }
0818:
0819: /**
0820: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterPresent(PreparedStatement, int)}
0821: */
0822: protected void verifyPreparedStatementParameterPresent(
0823: PreparedStatement statement, int indexOfParameter) {
0824: jdbcTestModule.verifyPreparedStatementParameterPresent(
0825: statement, indexOfParameter);
0826: }
0827:
0828: /**
0829: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterPresent(String, int)}
0830: */
0831: protected void verifyPreparedStatementParameterPresent(String sql,
0832: int indexOfParameter) {
0833: jdbcTestModule.verifyPreparedStatementParameterPresent(sql,
0834: indexOfParameter);
0835: }
0836:
0837: /**
0838: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterPresent(int, int)}
0839: */
0840: protected void verifyPreparedStatementParameterPresent(
0841: int indexOfStatement, int indexOfParameter) {
0842: jdbcTestModule.verifyPreparedStatementParameterPresent(
0843: indexOfStatement, indexOfParameter);
0844: }
0845:
0846: /**
0847: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterNotPresent(String, int)}
0848: */
0849: protected void verifyPreparedStatementParameterNotPresent(
0850: String sql, int indexOfParameter) {
0851: jdbcTestModule.verifyPreparedStatementParameterNotPresent(sql,
0852: indexOfParameter);
0853: }
0854:
0855: /**
0856: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterNotPresent(PreparedStatement, int)}
0857: */
0858: protected void verifyPreparedStatementParameterNotPresent(
0859: PreparedStatement statement, int indexOfParameter) {
0860: jdbcTestModule.verifyPreparedStatementParameterNotPresent(
0861: statement, indexOfParameter);
0862: }
0863:
0864: /**
0865: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterNotPresent(int, int)}
0866: */
0867: protected void verifyPreparedStatementParameterNotPresent(
0868: int indexOfStatement, int indexOfParameter) {
0869: jdbcTestModule.verifyPreparedStatementParameterNotPresent(
0870: indexOfStatement, indexOfParameter);
0871: }
0872:
0873: /**
0874: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(int, String)}
0875: */
0876: protected void verifyCallableStatementParameterPresent(
0877: int indexOfStatement, String nameOfParameter) {
0878: jdbcTestModule.verifyCallableStatementParameterPresent(
0879: indexOfStatement, nameOfParameter);
0880: }
0881:
0882: /**
0883: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(CallableStatement, int)}
0884: */
0885: protected void verifyCallableStatementParameterPresent(
0886: CallableStatement statement, int indexOfParameter) {
0887: jdbcTestModule.verifyCallableStatementParameterPresent(
0888: statement, indexOfParameter);
0889: }
0890:
0891: /**
0892: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(String, int)}
0893: */
0894: protected void verifyCallableStatementParameterPresent(String sql,
0895: int indexOfParameter) {
0896: jdbcTestModule.verifyCallableStatementParameterPresent(sql,
0897: indexOfParameter);
0898: }
0899:
0900: /**
0901: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(int, int)}
0902: */
0903: protected void verifyCallableStatementParameterPresent(
0904: int indexOfStatement, int indexOfParameter) {
0905: jdbcTestModule.verifyCallableStatementParameterPresent(
0906: indexOfStatement, indexOfParameter);
0907: }
0908:
0909: /**
0910: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(String, String)}
0911: */
0912: protected void verifyCallableStatementParameterPresent(String sql,
0913: String nameOfParameter) {
0914: jdbcTestModule.verifyCallableStatementParameterPresent(sql,
0915: nameOfParameter);
0916: }
0917:
0918: /**
0919: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(CallableStatement, String)}
0920: */
0921: protected void verifyCallableStatementParameterPresent(
0922: CallableStatement statement, String nameOfParameter) {
0923: jdbcTestModule.verifyCallableStatementParameterPresent(
0924: statement, nameOfParameter);
0925: }
0926:
0927: /**
0928: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(CallableStatement, String)}
0929: */
0930: protected void verifyCallableStatementParameterNotPresent(
0931: CallableStatement statement, String nameOfParameter) {
0932: jdbcTestModule.verifyCallableStatementParameterNotPresent(
0933: statement, nameOfParameter);
0934: }
0935:
0936: /**
0937: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(int, int)}
0938: */
0939: protected void verifyCallableStatementParameterNotPresent(
0940: int indexOfStatement, int indexOfParameter) {
0941: jdbcTestModule.verifyCallableStatementParameterNotPresent(
0942: indexOfStatement, indexOfParameter);
0943: }
0944:
0945: /**
0946: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(CallableStatement, int)}
0947: */
0948: protected void verifyCallableStatementParameterNotPresent(
0949: CallableStatement statement, int indexOfParameter) {
0950: jdbcTestModule.verifyCallableStatementParameterNotPresent(
0951: statement, indexOfParameter);
0952: }
0953:
0954: /**
0955: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(String, int)}
0956: */
0957: protected void verifyCallableStatementParameterNotPresent(
0958: String sql, int indexOfParameter) {
0959: jdbcTestModule.verifyCallableStatementParameterNotPresent(sql,
0960: indexOfParameter);
0961: }
0962:
0963: /**
0964: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(int, String)}
0965: */
0966: protected void verifyCallableStatementParameterNotPresent(
0967: int indexOfStatement, String nameOfParameter) {
0968: jdbcTestModule.verifyCallableStatementParameterNotPresent(
0969: indexOfStatement, nameOfParameter);
0970: }
0971:
0972: /**
0973: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(String, String)}
0974: */
0975: protected void verifyCallableStatementParameterNotPresent(
0976: String sql, String nameOfParameter) {
0977: jdbcTestModule.verifyCallableStatementParameterNotPresent(sql,
0978: nameOfParameter);
0979: }
0980:
0981: /**
0982: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameter(PreparedStatement, int, Object)}
0983: */
0984: protected void verifyPreparedStatementParameter(
0985: PreparedStatement statement, int indexOfParameter,
0986: Object object) {
0987: jdbcTestModule.verifyPreparedStatementParameter(statement,
0988: indexOfParameter, object);
0989: }
0990:
0991: /**
0992: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameter(String, int, Object)}
0993: */
0994: protected void verifyPreparedStatementParameter(String sql,
0995: int indexOfParameter, Object object) {
0996: jdbcTestModule.verifyPreparedStatementParameter(sql,
0997: indexOfParameter, object);
0998: }
0999:
1000: /**
1001: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameter(int, int, Object)}
1002: */
1003: protected void verifyPreparedStatementParameter(
1004: int indexOfStatement, int indexOfParameter, Object object) {
1005: jdbcTestModule.verifyPreparedStatementParameter(
1006: indexOfStatement, indexOfParameter, object);
1007: }
1008:
1009: /**
1010: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(int, String, Object)}
1011: */
1012: protected void verifyCallableStatementParameter(
1013: int indexOfStatement, String nameOfParameter, Object object) {
1014: jdbcTestModule.verifyCallableStatementParameter(
1015: indexOfStatement, nameOfParameter, object);
1016: }
1017:
1018: /**
1019: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(CallableStatement, int, Object)}
1020: */
1021: protected void verifyCallableStatementParameter(
1022: CallableStatement statement, int indexOfParameter,
1023: Object object) {
1024: jdbcTestModule.verifyCallableStatementParameter(statement,
1025: indexOfParameter, object);
1026: }
1027:
1028: /**
1029: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(String, int, Object)}
1030: */
1031: protected void verifyCallableStatementParameter(String sql,
1032: int indexOfParameter, Object object) {
1033: jdbcTestModule.verifyCallableStatementParameter(sql,
1034: indexOfParameter, object);
1035: }
1036:
1037: /**
1038: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(int, int, Object)}
1039: */
1040: protected void verifyCallableStatementParameter(
1041: int indexOfStatement, int indexOfParameter, Object object) {
1042: jdbcTestModule.verifyCallableStatementParameter(
1043: indexOfStatement, indexOfParameter, object);
1044: }
1045:
1046: /**
1047: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(CallableStatement, String, Object)}
1048: */
1049: protected void verifyCallableStatementParameter(
1050: CallableStatement statement, String nameOfParameter,
1051: Object object) {
1052: jdbcTestModule.verifyCallableStatementParameter(statement,
1053: nameOfParameter, object);
1054: }
1055:
1056: /**
1057: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(String, String, Object)}
1058: */
1059: protected void verifyCallableStatementParameter(String sql,
1060: String nameOfParameter, Object object) {
1061: jdbcTestModule.verifyCallableStatementParameter(sql,
1062: nameOfParameter, object);
1063: }
1064:
1065: /**
1066: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(CallableStatement, int)}
1067: */
1068: protected void verifyCallableStatementOutParameterRegistered(
1069: CallableStatement statement, int indexOfParameter) {
1070: jdbcTestModule.verifyCallableStatementOutParameterRegistered(
1071: statement, indexOfParameter);
1072: }
1073:
1074: /**
1075: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(String, int)}
1076: */
1077: protected void verifyCallableStatementOutParameterRegistered(
1078: String sql, int indexOfParameter) {
1079: jdbcTestModule.verifyCallableStatementOutParameterRegistered(
1080: sql, indexOfParameter);
1081: }
1082:
1083: /**
1084: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(int, int)}
1085: */
1086: protected void verifyCallableStatementOutParameterRegistered(
1087: int indexOfStatement, int indexOfParameter) {
1088: jdbcTestModule.verifyCallableStatementOutParameterRegistered(
1089: indexOfStatement, indexOfParameter);
1090: }
1091:
1092: /**
1093: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(CallableStatement, String)}
1094: */
1095: protected void verifyCallableStatementOutParameterRegistered(
1096: CallableStatement statement, String nameOfParameter) {
1097: jdbcTestModule.verifyCallableStatementOutParameterRegistered(
1098: statement, nameOfParameter);
1099: }
1100:
1101: /**
1102: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(String, String)}
1103: */
1104: protected void verifyCallableStatementOutParameterRegistered(
1105: String sql, String nameOfParameter) {
1106: jdbcTestModule.verifyCallableStatementOutParameterRegistered(
1107: sql, nameOfParameter);
1108: }
1109:
1110: /**
1111: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(int, String)}
1112: */
1113: protected void verifyCallableStatementOutParameterRegistered(
1114: int indexOfStatement, String nameOfParameter) {
1115: jdbcTestModule.verifyCallableStatementOutParameterRegistered(
1116: indexOfStatement, nameOfParameter);
1117: }
1118:
1119: /**
1120: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointPresent(String)}
1121: */
1122: /*protected void verifySavepointPresent(String name)
1123: {
1124: jdbcTestModule.verifySavepointPresent(name);
1125: }*/
1126:
1127: /**
1128: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointPresent(int)}
1129: */
1130: /*protected void verifySavepointPresent(int index)
1131: {
1132: jdbcTestModule.verifySavepointPresent(index);
1133: }*/
1134:
1135: /**
1136: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointReleased(int)}
1137: */
1138: /*protected void verifySavepointReleased(int index)
1139: {
1140: jdbcTestModule.verifySavepointReleased(index);
1141: }*/
1142:
1143: /**
1144: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointReleased(String)}
1145: */
1146: /*protected void verifySavepointReleased(String name)
1147: {
1148: jdbcTestModule.verifySavepointReleased(name);
1149: }*/
1150:
1151: /**
1152: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotReleased(int)}
1153: */
1154: /*protected void verifySavepointNotReleased(int index)
1155: {
1156: jdbcTestModule.verifySavepointNotReleased(index);
1157: }*/
1158:
1159: /**
1160: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotReleased(String)}
1161: */
1162: /*protected void verifySavepointNotReleased(String name)
1163: {
1164: jdbcTestModule.verifySavepointNotReleased(name);
1165: }*/
1166:
1167: /**
1168: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointRolledBack(int)}
1169: */
1170: /*protected void verifySavepointRolledBack(int index)
1171: {
1172: jdbcTestModule.verifySavepointRolledBack(index);
1173: }*/
1174:
1175: /**
1176: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointRolledBack(String)}
1177: */
1178: /*protected void verifySavepointRolledBack(String name)
1179: {
1180: jdbcTestModule.verifySavepointRolledBack(name);
1181: }*/
1182:
1183: /**
1184: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRolledBack(String)}
1185: */
1186: /*protected void verifySavepointNotRolledBack(String name)
1187: {
1188: jdbcTestModule.verifySavepointNotRolledBack(name);
1189: }*/
1190:
1191: /**
1192: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRolledBack(int)}
1193: */
1194: /*protected void verifySavepointNotRolledBack(int index)
1195: {
1196: jdbcTestModule.verifySavepointNotRolledBack(index);
1197: }*/
1198:
1199: /**
1200: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointRollbacked(String)}
1201: * @deprecated
1202: */
1203: /*protected void verifySavepointRollbacked(String name)
1204: {
1205: jdbcTestModule.verifySavepointRollbacked(name);
1206: }*/
1207:
1208: /**
1209: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointRollbacked(int)}
1210: * @deprecated
1211: */
1212: /*protected void verifySavepointRollbacked(int index)
1213: {
1214: jdbcTestModule.verifySavepointRollbacked(index);
1215: }*/
1216:
1217: /**
1218: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRollbacked(String)}
1219: * @deprecated
1220: */
1221: /*protected void verifySavepointNotRollbacked(String name)
1222: {
1223: jdbcTestModule.verifySavepointNotRollbacked(name);
1224: }*/
1225:
1226: /**
1227: * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRollbacked(int)}
1228: * @deprecated
1229: */
1230: /*protected void verifySavepointNotRollbacked(int index)
1231: {
1232: jdbcTestModule.verifySavepointNotRollbacked(index);
1233: }*/
1234: }
|