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