001    package com.mockrunner.jdbc;
002    
003    import java.sql.CallableStatement;
004    import java.sql.PreparedStatement;
005    import java.util.List;
006    import java.util.Map;
007    
008    import junit.framework.TestCase;
009    
010    import com.mockrunner.mock.jdbc.JDBCMockObjectFactory;
011    import com.mockrunner.mock.jdbc.MockCallableStatement;
012    import com.mockrunner.mock.jdbc.MockPreparedStatement;
013    import com.mockrunner.mock.jdbc.MockResultSet;
014    import com.mockrunner.mock.jdbc.MockSavepoint;
015    import com.mockrunner.mock.jdbc.MockStatement;
016    
017    /**
018     * Delegator for {@link com.mockrunner.jdbc.JDBCTestModule}. You can
019     * subclass this adapter or use {@link com.mockrunner.jdbc.JDBCTestModule}
020     * directly (so your test case can use another base class).
021     * This basic adapter can be used if you don't need any other modules. It
022     * does not extend {@link com.mockrunner.base.BaseTestCase}. If you want
023     * to use several modules in conjunction, consider subclassing
024     * {@link com.mockrunner.jdbc.JDBCTestCaseAdapter}.
025     * <b>This class is generated from the {@link com.mockrunner.jdbc.JDBCTestModule}
026     * and should not be edited directly</b>.
027     */
028    public class BasicJDBCTestCaseAdapter extends TestCase
029    {
030        private JDBCTestModule jdbcTestModule;
031        private JDBCMockObjectFactory jdbcMockObjectFactory;
032    
033        public BasicJDBCTestCaseAdapter()
034        {
035    
036        }
037    
038        public BasicJDBCTestCaseAdapter(String name)
039        {
040            super(name);
041        }
042    
043        protected void tearDown() throws Exception
044        {
045            super.tearDown();
046            jdbcTestModule = null;
047            jdbcMockObjectFactory = null;
048        }
049    
050        /**
051         * Creates the {@link com.mockrunner.jdbc.JDBCTestModule}. If you
052         * overwrite this method, you must call <code>super.setUp()</code>.
053         */
054        protected void setUp() throws Exception
055        {
056            super.setUp();
057            jdbcMockObjectFactory = createJDBCMockObjectFactory();
058            jdbcTestModule = createJDBCTestModule(getJDBCMockObjectFactory());
059        }
060    
061        /**
062         * Creates a {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
063         * @return the created {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}
064         */
065        protected JDBCMockObjectFactory createJDBCMockObjectFactory()
066        {
067            return new JDBCMockObjectFactory();
068        }
069    
070        /**
071         * Gets the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
072         * @return the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}
073         */
074        protected JDBCMockObjectFactory getJDBCMockObjectFactory()
075        {
076            return jdbcMockObjectFactory;
077        }
078    
079        /**
080         * Sets the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
081         * @param jdbcMockObjectFactory the {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}
082         */
083        protected void setJDBCMockObjectFactory(JDBCMockObjectFactory jdbcMockObjectFactory)
084        {
085            this.jdbcMockObjectFactory = jdbcMockObjectFactory;
086        }
087    
088        /**
089         * Creates a {@link com.mockrunner.jdbc.JDBCTestModule} based on the current
090         * {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
091         * Same as <code>createJDBCTestModule(getJDBCMockObjectFactory())</code>.
092         * @return the created {@link com.mockrunner.jdbc.JDBCTestModule}
093         */
094        protected JDBCTestModule createJDBCTestModule()
095        {
096            return new JDBCTestModule(getJDBCMockObjectFactory());
097        }
098    
099        /**
100         * Creates a {@link com.mockrunner.jdbc.JDBCTestModule} with the specified
101         * {@link com.mockrunner.mock.jdbc.JDBCMockObjectFactory}.
102         * @return the created {@link com.mockrunner.jdbc.JDBCTestModule}
103         */
104        protected JDBCTestModule createJDBCTestModule(JDBCMockObjectFactory mockFactory)
105        {
106            return new JDBCTestModule(mockFactory);
107        }
108    
109        /**
110         * Gets the {@link com.mockrunner.jdbc.JDBCTestModule}.
111         * @return the {@link com.mockrunner.jdbc.JDBCTestModule}
112         */
113        protected JDBCTestModule getJDBCTestModule()
114        {
115            return jdbcTestModule;
116        }
117    
118        /**
119         * Sets the {@link com.mockrunner.jdbc.JDBCTestModule}.
120         * @param jdbcTestModule the {@link com.mockrunner.jdbc.JDBCTestModule}
121         */
122        protected void setJDBCTestModule(JDBCTestModule jdbcTestModule)
123        {
124            this.jdbcTestModule = jdbcTestModule;
125        }
126    
127        /**
128         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#setCaseSensitive(boolean)}
129         */
130        protected void setCaseSensitive(boolean caseSensitive)
131        {
132            jdbcTestModule.setCaseSensitive(caseSensitive);
133        }
134    
135        /**
136         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCommitted}
137         */
138        protected void verifyCommitted()
139        {
140            jdbcTestModule.verifyCommitted();
141        }
142    
143        /**
144         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNotCommitted}
145         */
146        protected void verifyNotCommitted()
147        {
148            jdbcTestModule.verifyNotCommitted();
149        }
150    
151        /**
152         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyRolledBack}
153         */
154        protected void verifyRolledBack()
155        {
156            jdbcTestModule.verifyRolledBack();
157        }
158    
159        /**
160         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNotRolledBack}
161         */
162        protected void verifyNotRolledBack()
163        {
164            jdbcTestModule.verifyNotRolledBack();
165        }
166    
167        /**
168         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#setExactMatch(boolean)}
169         */
170        protected void setExactMatch(boolean exactMatch)
171        {
172            jdbcTestModule.setExactMatch(exactMatch);
173        }
174    
175        /**
176         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#setUseRegularExpressions(boolean)}
177         */
178        protected void setUseRegularExpressions(boolean useRegularExpressions)
179        {
180            jdbcTestModule.setUseRegularExpressions(useRegularExpressions);
181        }
182    
183        /**
184         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getStatementResultSetHandler}
185         */
186        protected StatementResultSetHandler getStatementResultSetHandler()
187        {
188            return jdbcTestModule.getStatementResultSetHandler();
189        }
190    
191        /**
192         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementResultSetHandler}
193         */
194        protected PreparedStatementResultSetHandler getPreparedStatementResultSetHandler()
195        {
196            return jdbcTestModule.getPreparedStatementResultSetHandler();
197        }
198    
199        /**
200         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementResultSetHandler}
201         */
202        protected CallableStatementResultSetHandler getCallableStatementResultSetHandler()
203        {
204            return jdbcTestModule.getCallableStatementResultSetHandler();
205        }
206    
207        /**
208         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getStatement(int)}
209         */
210        protected MockStatement getStatement(int index)
211        {
212            return jdbcTestModule.getStatement(index);
213        }
214    
215        /**
216         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getStatements}
217         */
218        protected List getStatements()
219        {
220            return jdbcTestModule.getStatements();
221        }
222    
223        /**
224         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getExecutedSQLStatements}
225         */
226        protected List getExecutedSQLStatements()
227        {
228            return jdbcTestModule.getExecutedSQLStatements();
229        }
230    
231        /**
232         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getExecutedSQLStatementParameter}
233         */
234        protected Map getExecutedSQLStatementParameter()
235        {
236            return jdbcTestModule.getExecutedSQLStatementParameter();
237        }
238    
239        /**
240         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getExecutedSQLStatementParameterSets(String)}
241         */
242        protected ParameterSets getExecutedSQLStatementParameterSets(String sql)
243        {
244            return jdbcTestModule.getExecutedSQLStatementParameterSets(sql);
245        }
246    
247        /**
248         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getReturnedResultSet(String)}
249         */
250        protected MockResultSet getReturnedResultSet(String id)
251        {
252            return jdbcTestModule.getReturnedResultSet(id);
253        }
254    
255        /**
256         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getReturnedResultSets(String)}
257         */
258        protected List getReturnedResultSets(String id)
259        {
260            return jdbcTestModule.getReturnedResultSets(id);
261        }
262    
263        /**
264         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getReturnedResultSets}
265         */
266        protected List getReturnedResultSets()
267        {
268            return jdbcTestModule.getReturnedResultSets();
269        }
270    
271        /**
272         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatement(String)}
273         */
274        protected MockPreparedStatement getPreparedStatement(String sql)
275        {
276            return jdbcTestModule.getPreparedStatement(sql);
277        }
278    
279        /**
280         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatement(int)}
281         */
282        protected MockPreparedStatement getPreparedStatement(int index)
283        {
284            return jdbcTestModule.getPreparedStatement(index);
285        }
286    
287        /**
288         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatements(String)}
289         */
290        protected List getPreparedStatements(String sql)
291        {
292            return jdbcTestModule.getPreparedStatements(sql);
293        }
294    
295        /**
296         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatements}
297         */
298        protected List getPreparedStatements()
299        {
300            return jdbcTestModule.getPreparedStatements();
301        }
302    
303        /**
304         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatement(String)}
305         */
306        protected MockCallableStatement getCallableStatement(String sql)
307        {
308            return jdbcTestModule.getCallableStatement(sql);
309        }
310    
311        /**
312         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatement(int)}
313         */
314        protected MockCallableStatement getCallableStatement(int index)
315        {
316            return jdbcTestModule.getCallableStatement(index);
317        }
318    
319        /**
320         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatements(String)}
321         */
322        protected List getCallableStatements(String sql)
323        {
324            return jdbcTestModule.getCallableStatements(sql);
325        }
326    
327        /**
328         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatements}
329         */
330        protected List getCallableStatements()
331        {
332            return jdbcTestModule.getCallableStatements();
333        }
334    
335        /**
336         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementParameter(PreparedStatement, int)}
337         */
338        protected Object getPreparedStatementParameter(PreparedStatement statement, int indexOfParameter)
339        {
340            return jdbcTestModule.getPreparedStatementParameter(statement, indexOfParameter);
341        }
342    
343        /**
344         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementParameter(String, int)}
345         */
346        protected Object getPreparedStatementParameter(String sql, int indexOfParameter)
347        {
348            return jdbcTestModule.getPreparedStatementParameter(sql, indexOfParameter);
349        }
350    
351        /**
352         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getPreparedStatementParameter(int, int)}
353         */
354        protected Object getPreparedStatementParameter(int indexOfStatement, int indexOfParameter)
355        {
356            return jdbcTestModule.getPreparedStatementParameter(indexOfStatement, indexOfParameter);
357        }
358    
359        /**
360         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(int, String)}
361         */
362        protected Object getCallableStatementParameter(int indexOfStatement, String nameOfParameter)
363        {
364            return jdbcTestModule.getCallableStatementParameter(indexOfStatement, nameOfParameter);
365        }
366    
367        /**
368         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(CallableStatement, String)}
369         */
370        protected Object getCallableStatementParameter(CallableStatement statement, String nameOfParameter)
371        {
372            return jdbcTestModule.getCallableStatementParameter(statement, nameOfParameter);
373        }
374    
375        /**
376         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(String, int)}
377         */
378        protected Object getCallableStatementParameter(String sql, int indexOfParameter)
379        {
380            return jdbcTestModule.getCallableStatementParameter(sql, indexOfParameter);
381        }
382    
383        /**
384         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(CallableStatement, int)}
385         */
386        protected Object getCallableStatementParameter(CallableStatement statement, int indexOfParameter)
387        {
388            return jdbcTestModule.getCallableStatementParameter(statement, indexOfParameter);
389        }
390    
391        /**
392         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(int, int)}
393         */
394        protected Object getCallableStatementParameter(int indexOfStatement, int indexOfParameter)
395        {
396            return jdbcTestModule.getCallableStatementParameter(indexOfStatement, indexOfParameter);
397        }
398    
399        /**
400         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getCallableStatementParameter(String, String)}
401         */
402        protected Object getCallableStatementParameter(String sql, String nameOfParameter)
403        {
404            return jdbcTestModule.getCallableStatementParameter(sql, nameOfParameter);
405        }
406    
407        /**
408         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getSavepoints}
409         */
410        protected List getSavepoints()
411        {
412            return jdbcTestModule.getSavepoints();
413        }
414    
415        /**
416         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getSavepoint(int)}
417         */
418        protected MockSavepoint getSavepoint(int index)
419        {
420            return jdbcTestModule.getSavepoint(index);
421        }
422    
423        /**
424         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#getSavepoint(String)}
425         */
426        protected MockSavepoint getSavepoint(String name)
427        {
428            return jdbcTestModule.getSavepoint(name);
429        }
430    
431        /**
432         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementExecuted(String)}
433         */
434        protected void verifySQLStatementExecuted(String sql)
435        {
436            jdbcTestModule.verifySQLStatementExecuted(sql);
437        }
438    
439        /**
440         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementNotExecuted(String)}
441         */
442        protected void verifySQLStatementNotExecuted(String sql)
443        {
444            jdbcTestModule.verifySQLStatementNotExecuted(sql);
445        }
446    
447        /**
448         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameterNumber(String, int, int)}
449         */
450        protected void verifySQLStatementParameterNumber(String sql, int indexOfParameterSet, int number)
451        {
452            jdbcTestModule.verifySQLStatementParameterNumber(sql, indexOfParameterSet, number);
453        }
454    
455        /**
456         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameter(String, int, String, Object)}
457         */
458        protected void verifySQLStatementParameter(String sql, int indexOfParameterSet, String nameOfParameter, Object expectedParameter)
459        {
460            jdbcTestModule.verifySQLStatementParameter(sql, indexOfParameterSet, nameOfParameter, expectedParameter);
461        }
462    
463        /**
464         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameter(String, int, int, Object)}
465         */
466        protected void verifySQLStatementParameter(String sql, int indexOfParameterSet, int indexOfParameter, Object expectedParameter)
467        {
468            jdbcTestModule.verifySQLStatementParameter(sql, indexOfParameterSet, indexOfParameter, expectedParameter);
469        }
470    
471        /**
472         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySQLStatementParameter(String, int, Map)}
473         */
474        protected void verifySQLStatementParameter(String sql, int indexOfParameterSet, Map parameterMap)
475        {
476            jdbcTestModule.verifySQLStatementParameter(sql, indexOfParameterSet, parameterMap);
477        }
478    
479        /**
480         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyConnectionClosed}
481         */
482        protected void verifyConnectionClosed()
483        {
484            jdbcTestModule.verifyConnectionClosed();
485        }
486    
487        /**
488         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyAllStatementsClosed}
489         */
490        protected void verifyAllStatementsClosed()
491        {
492            jdbcTestModule.verifyAllStatementsClosed();
493        }
494    
495        /**
496         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetClosed(String)}
497         */
498        protected void verifyResultSetClosed(String id)
499        {
500            jdbcTestModule.verifyResultSetClosed(id);
501        }
502    
503        /**
504         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowInserted(MockResultSet, int)}
505         */
506        protected void verifyResultSetRowInserted(MockResultSet resultSet, int number)
507        {
508            jdbcTestModule.verifyResultSetRowInserted(resultSet, number);
509        }
510    
511        /**
512         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowInserted(String, int)}
513         */
514        protected void verifyResultSetRowInserted(String id, int number)
515        {
516            jdbcTestModule.verifyResultSetRowInserted(id, number);
517        }
518    
519        /**
520         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotInserted(String, int)}
521         */
522        protected void verifyResultSetRowNotInserted(String id, int number)
523        {
524            jdbcTestModule.verifyResultSetRowNotInserted(id, number);
525        }
526    
527        /**
528         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotInserted(MockResultSet, int)}
529         */
530        protected void verifyResultSetRowNotInserted(MockResultSet resultSet, int number)
531        {
532            jdbcTestModule.verifyResultSetRowNotInserted(resultSet, number);
533        }
534    
535        /**
536         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowUpdated(MockResultSet, int)}
537         */
538        protected void verifyResultSetRowUpdated(MockResultSet resultSet, int number)
539        {
540            jdbcTestModule.verifyResultSetRowUpdated(resultSet, number);
541        }
542    
543        /**
544         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowUpdated(String, int)}
545         */
546        protected void verifyResultSetRowUpdated(String id, int number)
547        {
548            jdbcTestModule.verifyResultSetRowUpdated(id, number);
549        }
550    
551        /**
552         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotUpdated(MockResultSet, int)}
553         */
554        protected void verifyResultSetRowNotUpdated(MockResultSet resultSet, int number)
555        {
556            jdbcTestModule.verifyResultSetRowNotUpdated(resultSet, number);
557        }
558    
559        /**
560         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotUpdated(String, int)}
561         */
562        protected void verifyResultSetRowNotUpdated(String id, int number)
563        {
564            jdbcTestModule.verifyResultSetRowNotUpdated(id, number);
565        }
566    
567        /**
568         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowDeleted(MockResultSet, int)}
569         */
570        protected void verifyResultSetRowDeleted(MockResultSet resultSet, int number)
571        {
572            jdbcTestModule.verifyResultSetRowDeleted(resultSet, number);
573        }
574    
575        /**
576         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowDeleted(String, int)}
577         */
578        protected void verifyResultSetRowDeleted(String id, int number)
579        {
580            jdbcTestModule.verifyResultSetRowDeleted(id, number);
581        }
582    
583        /**
584         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotDeleted(String, int)}
585         */
586        protected void verifyResultSetRowNotDeleted(String id, int number)
587        {
588            jdbcTestModule.verifyResultSetRowNotDeleted(id, number);
589        }
590    
591        /**
592         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRowNotDeleted(MockResultSet, int)}
593         */
594        protected void verifyResultSetRowNotDeleted(MockResultSet resultSet, int number)
595        {
596            jdbcTestModule.verifyResultSetRowNotDeleted(resultSet, number);
597        }
598    
599        /**
600         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyAllResultSetsClosed}
601         */
602        protected void verifyAllResultSetsClosed()
603        {
604            jdbcTestModule.verifyAllResultSetsClosed();
605        }
606    
607        /**
608         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberCommits(int)}
609         */
610        protected void verifyNumberCommits(int number)
611        {
612            jdbcTestModule.verifyNumberCommits(number);
613        }
614    
615        /**
616         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberRollbacks(int)}
617         */
618        protected void verifyNumberRollbacks(int number)
619        {
620            jdbcTestModule.verifyNumberRollbacks(number);
621        }
622    
623        /**
624         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberStatements(int)}
625         */
626        protected void verifyNumberStatements(int number)
627        {
628            jdbcTestModule.verifyNumberStatements(number);
629        }
630    
631        /**
632         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberPreparedStatements(int, String)}
633         */
634        protected void verifyNumberPreparedStatements(int number, String sql)
635        {
636            jdbcTestModule.verifyNumberPreparedStatements(number, sql);
637        }
638    
639        /**
640         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberPreparedStatements(int)}
641         */
642        protected void verifyNumberPreparedStatements(int number)
643        {
644            jdbcTestModule.verifyNumberPreparedStatements(number);
645        }
646    
647        /**
648         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberCallableStatements(int)}
649         */
650        protected void verifyNumberCallableStatements(int number)
651        {
652            jdbcTestModule.verifyNumberCallableStatements(number);
653        }
654    
655        /**
656         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyNumberCallableStatements(int, String)}
657         */
658        protected void verifyNumberCallableStatements(int number, String sql)
659        {
660            jdbcTestModule.verifyNumberCallableStatements(number, sql);
661        }
662    
663        /**
664         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyStatementClosed(int)}
665         */
666        protected void verifyStatementClosed(int index)
667        {
668            jdbcTestModule.verifyStatementClosed(index);
669        }
670    
671        /**
672         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementClosed(String)}
673         */
674        protected void verifyPreparedStatementClosed(String sql)
675        {
676            jdbcTestModule.verifyPreparedStatementClosed(sql);
677        }
678    
679        /**
680         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementClosed(int)}
681         */
682        protected void verifyPreparedStatementClosed(int index)
683        {
684            jdbcTestModule.verifyPreparedStatementClosed(index);
685        }
686    
687        /**
688         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementClosed(String)}
689         */
690        protected void verifyCallableStatementClosed(String sql)
691        {
692            jdbcTestModule.verifyCallableStatementClosed(sql);
693        }
694    
695        /**
696         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementClosed(int)}
697         */
698        protected void verifyCallableStatementClosed(int index)
699        {
700            jdbcTestModule.verifyCallableStatementClosed(index);
701        }
702    
703        /**
704         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(MockResultSet, int, Object[])}
705         */
706        protected void verifyResultSetRow(MockResultSet resultSet, int number, Object[] rowData)
707        {
708            jdbcTestModule.verifyResultSetRow(resultSet, number, rowData);
709        }
710    
711        /**
712         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(String, int, List)}
713         */
714        protected void verifyResultSetRow(String id, int number, List rowData)
715        {
716            jdbcTestModule.verifyResultSetRow(id, number, rowData);
717        }
718    
719        /**
720         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(MockResultSet, int, List)}
721         */
722        protected void verifyResultSetRow(MockResultSet resultSet, int number, List rowData)
723        {
724            jdbcTestModule.verifyResultSetRow(resultSet, number, rowData);
725        }
726    
727        /**
728         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetRow(String, int, Object[])}
729         */
730        protected void verifyResultSetRow(String id, int number, Object[] rowData)
731        {
732            jdbcTestModule.verifyResultSetRow(id, number, rowData);
733        }
734    
735        /**
736         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, int, Object[])}
737         */
738        protected void verifyResultSetColumn(MockResultSet resultSet, int number, Object[] columnData)
739        {
740            jdbcTestModule.verifyResultSetColumn(resultSet, number, columnData);
741        }
742    
743        /**
744         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, int, List)}
745         */
746        protected void verifyResultSetColumn(String id, int number, List columnData)
747        {
748            jdbcTestModule.verifyResultSetColumn(id, number, columnData);
749        }
750    
751        /**
752         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, int, Object[])}
753         */
754        protected void verifyResultSetColumn(String id, int number, Object[] columnData)
755        {
756            jdbcTestModule.verifyResultSetColumn(id, number, columnData);
757        }
758    
759        /**
760         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, String, List)}
761         */
762        protected void verifyResultSetColumn(MockResultSet resultSet, String name, List columnData)
763        {
764            jdbcTestModule.verifyResultSetColumn(resultSet, name, columnData);
765        }
766    
767        /**
768         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, String, Object[])}
769         */
770        protected void verifyResultSetColumn(MockResultSet resultSet, String name, Object[] columnData)
771        {
772            jdbcTestModule.verifyResultSetColumn(resultSet, name, columnData);
773        }
774    
775        /**
776         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, String, List)}
777         */
778        protected void verifyResultSetColumn(String id, String name, List columnData)
779        {
780            jdbcTestModule.verifyResultSetColumn(id, name, columnData);
781        }
782    
783        /**
784         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(MockResultSet, int, List)}
785         */
786        protected void verifyResultSetColumn(MockResultSet resultSet, int number, List columnData)
787        {
788            jdbcTestModule.verifyResultSetColumn(resultSet, number, columnData);
789        }
790    
791        /**
792         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetColumn(String, String, Object[])}
793         */
794        protected void verifyResultSetColumn(String id, String name, Object[] columnData)
795        {
796            jdbcTestModule.verifyResultSetColumn(id, name, columnData);
797        }
798    
799        /**
800         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetEquals(String, MockResultSet)}
801         */
802        protected void verifyResultSetEquals(String id, MockResultSet target)
803        {
804            jdbcTestModule.verifyResultSetEquals(id, target);
805        }
806    
807        /**
808         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyResultSetEquals(MockResultSet, MockResultSet)}
809         */
810        protected void verifyResultSetEquals(MockResultSet source, MockResultSet target)
811        {
812            jdbcTestModule.verifyResultSetEquals(source, target);
813        }
814    
815        /**
816         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementPresent(String)}
817         */
818        protected void verifyPreparedStatementPresent(String sql)
819        {
820            jdbcTestModule.verifyPreparedStatementPresent(sql);
821        }
822    
823        /**
824         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementNotPresent(String)}
825         */
826        protected void verifyPreparedStatementNotPresent(String sql)
827        {
828            jdbcTestModule.verifyPreparedStatementNotPresent(sql);
829        }
830    
831        /**
832         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementPresent(String)}
833         */
834        protected void verifyCallableStatementPresent(String sql)
835        {
836            jdbcTestModule.verifyCallableStatementPresent(sql);
837        }
838    
839        /**
840         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementNotPresent(String)}
841         */
842        protected void verifyCallableStatementNotPresent(String sql)
843        {
844            jdbcTestModule.verifyCallableStatementNotPresent(sql);
845        }
846    
847        /**
848         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterPresent(PreparedStatement, int)}
849         */
850        protected void verifyPreparedStatementParameterPresent(PreparedStatement statement, int indexOfParameter)
851        {
852            jdbcTestModule.verifyPreparedStatementParameterPresent(statement, indexOfParameter);
853        }
854    
855        /**
856         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterPresent(String, int)}
857         */
858        protected void verifyPreparedStatementParameterPresent(String sql, int indexOfParameter)
859        {
860            jdbcTestModule.verifyPreparedStatementParameterPresent(sql, indexOfParameter);
861        }
862    
863        /**
864         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterPresent(int, int)}
865         */
866        protected void verifyPreparedStatementParameterPresent(int indexOfStatement, int indexOfParameter)
867        {
868            jdbcTestModule.verifyPreparedStatementParameterPresent(indexOfStatement, indexOfParameter);
869        }
870    
871        /**
872         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterNotPresent(String, int)}
873         */
874        protected void verifyPreparedStatementParameterNotPresent(String sql, int indexOfParameter)
875        {
876            jdbcTestModule.verifyPreparedStatementParameterNotPresent(sql, indexOfParameter);
877        }
878    
879        /**
880         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterNotPresent(int, int)}
881         */
882        protected void verifyPreparedStatementParameterNotPresent(int indexOfStatement, int indexOfParameter)
883        {
884            jdbcTestModule.verifyPreparedStatementParameterNotPresent(indexOfStatement, indexOfParameter);
885        }
886    
887        /**
888         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameterNotPresent(PreparedStatement, int)}
889         */
890        protected void verifyPreparedStatementParameterNotPresent(PreparedStatement statement, int indexOfParameter)
891        {
892            jdbcTestModule.verifyPreparedStatementParameterNotPresent(statement, indexOfParameter);
893        }
894    
895        /**
896         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(String, int)}
897         */
898        protected void verifyCallableStatementParameterPresent(String sql, int indexOfParameter)
899        {
900            jdbcTestModule.verifyCallableStatementParameterPresent(sql, indexOfParameter);
901        }
902    
903        /**
904         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(int, int)}
905         */
906        protected void verifyCallableStatementParameterPresent(int indexOfStatement, int indexOfParameter)
907        {
908            jdbcTestModule.verifyCallableStatementParameterPresent(indexOfStatement, indexOfParameter);
909        }
910    
911        /**
912         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(CallableStatement, int)}
913         */
914        protected void verifyCallableStatementParameterPresent(CallableStatement statement, int indexOfParameter)
915        {
916            jdbcTestModule.verifyCallableStatementParameterPresent(statement, indexOfParameter);
917        }
918    
919        /**
920         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(CallableStatement, String)}
921         */
922        protected void verifyCallableStatementParameterPresent(CallableStatement statement, String nameOfParameter)
923        {
924            jdbcTestModule.verifyCallableStatementParameterPresent(statement, nameOfParameter);
925        }
926    
927        /**
928         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(int, String)}
929         */
930        protected void verifyCallableStatementParameterPresent(int indexOfStatement, String nameOfParameter)
931        {
932            jdbcTestModule.verifyCallableStatementParameterPresent(indexOfStatement, nameOfParameter);
933        }
934    
935        /**
936         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterPresent(String, String)}
937         */
938        protected void verifyCallableStatementParameterPresent(String sql, String nameOfParameter)
939        {
940            jdbcTestModule.verifyCallableStatementParameterPresent(sql, nameOfParameter);
941        }
942    
943        /**
944         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(CallableStatement, int)}
945         */
946        protected void verifyCallableStatementParameterNotPresent(CallableStatement statement, int indexOfParameter)
947        {
948            jdbcTestModule.verifyCallableStatementParameterNotPresent(statement, indexOfParameter);
949        }
950    
951        /**
952         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(String, int)}
953         */
954        protected void verifyCallableStatementParameterNotPresent(String sql, int indexOfParameter)
955        {
956            jdbcTestModule.verifyCallableStatementParameterNotPresent(sql, indexOfParameter);
957        }
958    
959        /**
960         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(CallableStatement, String)}
961         */
962        protected void verifyCallableStatementParameterNotPresent(CallableStatement statement, String nameOfParameter)
963        {
964            jdbcTestModule.verifyCallableStatementParameterNotPresent(statement, nameOfParameter);
965        }
966    
967        /**
968         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(String, String)}
969         */
970        protected void verifyCallableStatementParameterNotPresent(String sql, String nameOfParameter)
971        {
972            jdbcTestModule.verifyCallableStatementParameterNotPresent(sql, nameOfParameter);
973        }
974    
975        /**
976         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(int, String)}
977         */
978        protected void verifyCallableStatementParameterNotPresent(int indexOfStatement, String nameOfParameter)
979        {
980            jdbcTestModule.verifyCallableStatementParameterNotPresent(indexOfStatement, nameOfParameter);
981        }
982    
983        /**
984         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameterNotPresent(int, int)}
985         */
986        protected void verifyCallableStatementParameterNotPresent(int indexOfStatement, int indexOfParameter)
987        {
988            jdbcTestModule.verifyCallableStatementParameterNotPresent(indexOfStatement, indexOfParameter);
989        }
990    
991        /**
992         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameter(PreparedStatement, int, Object)}
993         */
994        protected void verifyPreparedStatementParameter(PreparedStatement statement, int indexOfParameter, Object object)
995        {
996            jdbcTestModule.verifyPreparedStatementParameter(statement, indexOfParameter, object);
997        }
998    
999        /**
1000         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameter(String, int, Object)}
1001         */
1002        protected void verifyPreparedStatementParameter(String sql, int indexOfParameter, Object object)
1003        {
1004            jdbcTestModule.verifyPreparedStatementParameter(sql, indexOfParameter, object);
1005        }
1006    
1007        /**
1008         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyPreparedStatementParameter(int, int, Object)}
1009         */
1010        protected void verifyPreparedStatementParameter(int indexOfStatement, int indexOfParameter, Object object)
1011        {
1012            jdbcTestModule.verifyPreparedStatementParameter(indexOfStatement, indexOfParameter, object);
1013        }
1014    
1015        /**
1016         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(String, int, Object)}
1017         */
1018        protected void verifyCallableStatementParameter(String sql, int indexOfParameter, Object object)
1019        {
1020            jdbcTestModule.verifyCallableStatementParameter(sql, indexOfParameter, object);
1021        }
1022    
1023        /**
1024         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(int, int, Object)}
1025         */
1026        protected void verifyCallableStatementParameter(int indexOfStatement, int indexOfParameter, Object object)
1027        {
1028            jdbcTestModule.verifyCallableStatementParameter(indexOfStatement, indexOfParameter, object);
1029        }
1030    
1031        /**
1032         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(CallableStatement, String, Object)}
1033         */
1034        protected void verifyCallableStatementParameter(CallableStatement statement, String nameOfParameter, Object object)
1035        {
1036            jdbcTestModule.verifyCallableStatementParameter(statement, nameOfParameter, object);
1037        }
1038    
1039        /**
1040         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(String, String, Object)}
1041         */
1042        protected void verifyCallableStatementParameter(String sql, String nameOfParameter, Object object)
1043        {
1044            jdbcTestModule.verifyCallableStatementParameter(sql, nameOfParameter, object);
1045        }
1046    
1047        /**
1048         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(int, String, Object)}
1049         */
1050        protected void verifyCallableStatementParameter(int indexOfStatement, String nameOfParameter, Object object)
1051        {
1052            jdbcTestModule.verifyCallableStatementParameter(indexOfStatement, nameOfParameter, object);
1053        }
1054    
1055        /**
1056         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementParameter(CallableStatement, int, Object)}
1057         */
1058        protected void verifyCallableStatementParameter(CallableStatement statement, int indexOfParameter, Object object)
1059        {
1060            jdbcTestModule.verifyCallableStatementParameter(statement, indexOfParameter, object);
1061        }
1062    
1063        /**
1064         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(CallableStatement, int)}
1065         */
1066        protected void verifyCallableStatementOutParameterRegistered(CallableStatement statement, int indexOfParameter)
1067        {
1068            jdbcTestModule.verifyCallableStatementOutParameterRegistered(statement, indexOfParameter);
1069        }
1070    
1071        /**
1072         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(String, int)}
1073         */
1074        protected void verifyCallableStatementOutParameterRegistered(String sql, int indexOfParameter)
1075        {
1076            jdbcTestModule.verifyCallableStatementOutParameterRegistered(sql, indexOfParameter);
1077        }
1078    
1079        /**
1080         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(int, int)}
1081         */
1082        protected void verifyCallableStatementOutParameterRegistered(int indexOfStatement, int indexOfParameter)
1083        {
1084            jdbcTestModule.verifyCallableStatementOutParameterRegistered(indexOfStatement, indexOfParameter);
1085        }
1086    
1087        /**
1088         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(CallableStatement, String)}
1089         */
1090        protected void verifyCallableStatementOutParameterRegistered(CallableStatement statement, String nameOfParameter)
1091        {
1092            jdbcTestModule.verifyCallableStatementOutParameterRegistered(statement, nameOfParameter);
1093        }
1094    
1095        /**
1096         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(String, String)}
1097         */
1098        protected void verifyCallableStatementOutParameterRegistered(String sql, String nameOfParameter)
1099        {
1100            jdbcTestModule.verifyCallableStatementOutParameterRegistered(sql, nameOfParameter);
1101        }
1102    
1103        /**
1104         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifyCallableStatementOutParameterRegistered(int, String)}
1105         */
1106        protected void verifyCallableStatementOutParameterRegistered(int indexOfStatement, String nameOfParameter)
1107        {
1108            jdbcTestModule.verifyCallableStatementOutParameterRegistered(indexOfStatement, nameOfParameter);
1109        }
1110    
1111        /**
1112         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointPresent(String)}
1113         */
1114        protected void verifySavepointPresent(String name)
1115        {
1116            jdbcTestModule.verifySavepointPresent(name);
1117        }
1118    
1119        /**
1120         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointPresent(int)}
1121         */
1122        protected void verifySavepointPresent(int index)
1123        {
1124            jdbcTestModule.verifySavepointPresent(index);
1125        }
1126    
1127        /**
1128         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointReleased(String)}
1129         */
1130        protected void verifySavepointReleased(String name)
1131        {
1132            jdbcTestModule.verifySavepointReleased(name);
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#verifySavepointNotReleased(String)}
1145         */
1146        protected void verifySavepointNotReleased(String name)
1147        {
1148            jdbcTestModule.verifySavepointNotReleased(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#verifySavepointRolledBack(int)}
1161         */
1162        protected void verifySavepointRolledBack(int index)
1163        {
1164            jdbcTestModule.verifySavepointRolledBack(index);
1165        }
1166    
1167        /**
1168         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointRolledBack(String)}
1169         */
1170        protected void verifySavepointRolledBack(String name)
1171        {
1172            jdbcTestModule.verifySavepointRolledBack(name);
1173        }
1174    
1175        /**
1176         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRolledBack(String)}
1177         */
1178        protected void verifySavepointNotRolledBack(String name)
1179        {
1180            jdbcTestModule.verifySavepointNotRolledBack(name);
1181        }
1182    
1183        /**
1184         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRolledBack(int)}
1185         */
1186        protected void verifySavepointNotRolledBack(int index)
1187        {
1188            jdbcTestModule.verifySavepointNotRolledBack(index);
1189        }
1190    
1191        /**
1192         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointRollbacked(String)}
1193         * @deprecated
1194         */
1195        protected void verifySavepointRollbacked(String name)
1196        {
1197            jdbcTestModule.verifySavepointRollbacked(name);
1198        }
1199    
1200        /**
1201         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointRollbacked(int)}
1202         * @deprecated
1203         */
1204        protected void verifySavepointRollbacked(int index)
1205        {
1206            jdbcTestModule.verifySavepointRollbacked(index);
1207        }
1208    
1209        /**
1210         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRollbacked(String)}
1211         * @deprecated
1212         */
1213        protected void verifySavepointNotRollbacked(String name)
1214        {
1215            jdbcTestModule.verifySavepointNotRollbacked(name);
1216        }
1217    
1218        /**
1219         * Delegates to {@link com.mockrunner.jdbc.JDBCTestModule#verifySavepointNotRollbacked(int)}
1220         * @deprecated
1221         */
1222        protected void verifySavepointNotRollbacked(int index)
1223        {
1224            jdbcTestModule.verifySavepointNotRollbacked(index);
1225        }
1226    }