001    package com.mockrunner.jdbc;
002    
003    import java.sql.CallableStatement;
004    import java.sql.PreparedStatement;
005    import java.sql.SQLException;
006    import java.util.ArrayList;
007    import java.util.HashMap;
008    import java.util.Iterator;
009    import java.util.List;
010    import java.util.Map;
011    
012    import com.mockrunner.base.NestedApplicationException;
013    import com.mockrunner.base.VerifyFailedException;
014    import com.mockrunner.mock.jdbc.JDBCMockObjectFactory;
015    import com.mockrunner.mock.jdbc.MockCallableStatement;
016    import com.mockrunner.mock.jdbc.MockPreparedStatement;
017    import com.mockrunner.mock.jdbc.MockResultSet;
018    import com.mockrunner.mock.jdbc.MockSavepoint;
019    import com.mockrunner.mock.jdbc.MockStatement;
020    import com.mockrunner.util.common.ArrayUtil;
021    import com.mockrunner.util.common.StringUtil;
022    
023    /**
024     * Module for JDBC tests.
025     */
026    public class JDBCTestModule
027    {
028        private JDBCMockObjectFactory mockFactory;
029        private boolean caseSensitive = false;
030        private boolean exactMatch = false;
031        private boolean useRegularExpressions = false;
032          
033        public JDBCTestModule(JDBCMockObjectFactory mockFactory)
034        {
035            this.mockFactory = mockFactory;
036        }
037        
038        /**
039         * Set if specified SQL statements should be handled case sensitive.
040         * Defaults to to <code>false</code>, i.e. <i>INSERT</i> is the same
041         * as <i>insert</i>. 
042         * Please note that this method controls SQL statement
043         * matching for this class, e.g. what statements the method
044         * {@link #getPreparedStatements(String)} returns or what statements
045         * are taken into account by the method {@link #verifySQLStatementExecuted(String)}.
046         * In contrast to {@link AbstractResultSetHandler#setCaseSensitive(boolean)} it does 
047         * not control the prepared results that are returned when the tested application
048         * executes a matching statement.
049         * @param caseSensitive enable or disable case sensitivity
050         */
051        public void setCaseSensitive(boolean caseSensitive)
052        {
053            this.caseSensitive = caseSensitive;
054        }
055        
056        /**
057         * Set if specified SQL statements must match exactly.
058         * Defaults to <code>false</code>, i.e. the SQL statement used
059         * to create a <code>PreparedStatement</code> must contain
060         * the specified SQL statement, but does not have to match
061         * exactly. If the original statement is <i>insert into mytable values(?, ?, ?)</i>
062         * <code>verifyPreparedStatementPresent("insert into mytable")</code>
063         * will pass.
064         * Please note that this method controls SQL statement
065         * matching for this class, e.g. what statements the method
066         * {@link #getPreparedStatements(String)} returns or what statements
067         * are taken into account by the method {@link #verifySQLStatementExecuted(String)}.
068         * In contrast to {@link AbstractResultSetHandler#setExactMatch(boolean)} it does 
069         * not control the prepared results that are returned when the tested application
070         * executes a matching statement.
071         * @param exactMatch enable or disable exact matching
072         */
073        public void setExactMatch(boolean exactMatch)
074        {
075            this.exactMatch = exactMatch;
076        }
077        
078        /**
079         * Set if regular expressions should be used when matching
080         * SQL statements. Irrelevant if <code>exactMatch</code> is
081         * <code>true</code>. Default is <code>false</code>, i.e. you
082         * cannot use regular expressions and matching is based
083         * on string comparison (which is much faster). Enable
084         * this feature only if necessary.
085         * Please note that this method controls SQL statement
086         * matching for this class, e.g. what statements the method
087         * {@link #getPreparedStatements(String)} returns or what statements
088         * are taken into account by the method {@link #verifySQLStatementExecuted(String)}.
089         * In contrast to {@link AbstractResultSetHandler#setUseRegularExpressions(boolean)} it does 
090         * not control the prepared results that are returned when the tested application
091         * executes a matching statement.
092         * @param useRegularExpressions should regular expressions be used
093         */
094        public void setUseRegularExpressions(boolean useRegularExpressions)
095        {
096            this.useRegularExpressions = useRegularExpressions;
097        }
098        
099        /**
100         * Returns the {@link StatementResultSetHandler}. 
101         * The {@link StatementResultSetHandler}
102         * contains methods that can be used to specify the 
103         * {@link com.mockrunner.mock.jdbc.MockResultSet} objects
104         * and update counts that a {@link com.mockrunner.mock.jdbc.MockStatement} 
105         * should return when executing an SQL statement.
106         * @return the {@link StatementResultSetHandler}
107         */
108        public StatementResultSetHandler getStatementResultSetHandler()
109        {
110            return mockFactory.getMockConnection().getStatementResultSetHandler();
111        }
112        
113        /**
114         * Returns the {@link PreparedStatementResultSetHandler}.
115         * The {@link PreparedStatementResultSetHandler}
116         * contains methods that can be used to specify the 
117         * {@link com.mockrunner.mock.jdbc.MockResultSet} objects
118         * and update counts that a {@link com.mockrunner.mock.jdbc.MockPreparedStatement} 
119         * should return when executing an SQL statement.
120         * @return the {@link PreparedStatementResultSetHandler}
121         */
122        public PreparedStatementResultSetHandler getPreparedStatementResultSetHandler()
123        {
124            return mockFactory.getMockConnection().getPreparedStatementResultSetHandler();
125        }
126        
127        /**
128         * Returns the {@link CallableStatementResultSetHandler}.
129         * The {@link CallableStatementResultSetHandler}
130         * contains methods that can be used to specify the 
131         * {@link com.mockrunner.mock.jdbc.MockResultSet} objects
132         * and update counts that a {@link com.mockrunner.mock.jdbc.MockCallableStatement} 
133         * should return when executing an SQL statement.
134         * @return the {@link CallableStatementResultSetHandler}
135         */
136        public CallableStatementResultSetHandler getCallableStatementResultSetHandler()
137        {
138            return mockFactory.getMockConnection().getCallableStatementResultSetHandler();
139        }
140        
141        /**
142         * Returns a {@link com.mockrunner.mock.jdbc.MockStatement} by its index.
143         * @param index the index of the <code>Statement</code>
144         * @return the <code>Statement</code> or <code>null</code>, if there is no such
145         *         <code>Statement</code>
146         */
147        public MockStatement getStatement(int index)
148        {
149            List statements = getStatements();
150            if(index < statements.size()) return (MockStatement)statements.get(index);
151            return null;
152        }
153        
154        /**
155         * Returns all {@link com.mockrunner.mock.jdbc.MockStatement} objects.
156         * @return the <code>List</code> of <code>Statement</code> objects
157         */
158        public List getStatements()
159        {
160            return mockFactory.getMockConnection().getStatementResultSetHandler().getStatements();
161        }
162        
163        /**
164         * Returns a <code>List</code> of all SQL statements that were executed
165         * by calling an <code>execute</code> method of a {@link com.mockrunner.mock.jdbc.MockStatement},
166         * {@link com.mockrunner.mock.jdbc.MockPreparedStatement} or
167         * {@link com.mockrunner.mock.jdbc.MockCallableStatement}.
168         * @return the <code>List</code> of SQL statements
169         */
170        public List getExecutedSQLStatements()
171        {
172            ArrayList list = new ArrayList();
173            list.addAll(mockFactory.getMockConnection().getStatementResultSetHandler().getExecutedStatements());
174            list.addAll(mockFactory.getMockConnection().getPreparedStatementResultSetHandler().getExecutedStatements());
175            list.addAll(mockFactory.getMockConnection().getCallableStatementResultSetHandler().getExecutedStatements());
176            return list;
177        }
178        
179            /**
180             * Returns a <code>Map</code> of all parameters that were used when
181         * executing a {@link com.mockrunner.mock.jdbc.MockPreparedStatement} or
182         * {@link com.mockrunner.mock.jdbc.MockCallableStatement}.
183             * The keys are the corresponding SQL statements. The values are the 
184         * {@link ParameterSets} objects.
185             * @return the <code>Map</code> of parameters
186             */
187            public Map getExecutedSQLStatementParameter()
188            {
189                    Map map = new HashMap();
190                    map.putAll(mockFactory.getMockConnection().getPreparedStatementResultSetHandler().getExecutedStatementParameter());
191                    map.putAll(mockFactory.getMockConnection().getCallableStatementResultSetHandler().getExecutedStatementParameter());
192                    return map;
193            }
194            
195            /**
196             * Returns the {@link ParameterSets} object for the specified SQL statement.
197             * If more than one {@link ParameterSets} object is found, the first one
198             * will be returned.
199             * @param sql the the SQL statement
200             * @return the {@link ParameterSets} object
201             */
202            public ParameterSets getExecutedSQLStatementParameterSets(String sql)
203            {
204                    Map map = getExecutedSQLStatementParameter();
205                    SQLStatementMatcher matcher = new SQLStatementMatcher(caseSensitive, exactMatch, useRegularExpressions);
206                    List list = matcher.getMatchingObjects(map, sql, false, false);
207                    if(list != null && list.size() > 0)
208            {
209                return (ParameterSets)list.get(0);
210            }
211            return null;
212            }
213        
214        /**
215         * Returns the <code>ResultSet</code> objects with the specified id. 
216         * If there are more than one <code>ResultSet</code> objects with the
217         * specified id, the first one is returned. If there is no
218         * <code>ResultSet</code> with the specified id, this method
219         * returns <code>null</code>.
220         * Please also see {@link #getReturnedResultSets(String)}.
221         * @return the <code>ResultSet</code> with the specified id
222         */
223        public MockResultSet getReturnedResultSet(String id)
224        {
225            List list = getReturnedResultSets(id);
226            if(list != null && list.size() > 0)
227            {
228                return (MockResultSet)list.get(0);
229            }
230            return null;
231        }
232        
233        /**
234         * Returns a <code>List</code> of the <code>ResultSet</code> objects with
235         * the specified id. Equivalent to {@link #getReturnedResultSets}, except
236         * that only <code>ResultSet</code> objects are added that have the
237         * corresponding id.
238         * Please note that <code>ResultSet</code> objects are cloned when executing 
239         * statements. The <code>ResultSet</code> objects in the <code>List</code>
240         * returned by this method are really the instances the statement returned
241         * and not the instances you have used when preparing them.
242         * @return the <code>List</code> of <code>ResultSet</code> objects
243         */
244        public List getReturnedResultSets(String id)
245        {
246            List list = getReturnedResultSets();
247            ArrayList resultList = new ArrayList();
248            for(int ii = 0; ii < list.size(); ii++)
249            {
250                MockResultSet resultSet = (MockResultSet)list.get(ii);
251                if(id.equals(resultSet.getId()))
252                {
253                    resultList.add(resultSet);
254                }
255            }
256            return resultList;
257        }
258        
259        /**
260         * Returns a <code>List</code> of all <code>ResultSet</code> objects that were returned
261         * by calling an <code>executeQuery</code> method of a {@link com.mockrunner.mock.jdbc.MockStatement},
262         * {@link com.mockrunner.mock.jdbc.MockPreparedStatement} or
263         * {@link com.mockrunner.mock.jdbc.MockCallableStatement}.
264         * Please note that <code>ResultSet</code> objects are cloned when executing 
265         * statements. The <code>ResultSet</code> objects in the <code>List</code>
266         * returned by this method are really the instances the statement returned
267         * and not the instances you have used when preparing them.
268         * @return the <code>List</code> of <code>ResultSet</code> objects
269         */
270        public List getReturnedResultSets()
271        {
272            ArrayList list = new ArrayList();
273            list.addAll(mockFactory.getMockConnection().getStatementResultSetHandler().getReturnedResultSets());
274            list.addAll(mockFactory.getMockConnection().getPreparedStatementResultSetHandler().getReturnedResultSets());
275            list.addAll(mockFactory.getMockConnection().getCallableStatementResultSetHandler().getReturnedResultSets());
276            return list;
277        }
278        
279        /**
280         * Returns a {@link com.mockrunner.mock.jdbc.MockPreparedStatement} that was 
281         * created using a {@link com.mockrunner.mock.jdbc.MockConnection} by its index.
282         * @param index the index of the <code>PreparedStatement</code>
283         * @return the <code>PreparedStatement</code> or <code>null</code>, if there is no such
284         *         <code>PreparedStatement</code>
285         */
286        public MockPreparedStatement getPreparedStatement(int index)
287        {
288            List statements = getPreparedStatements();
289            if(index < statements.size()) return (MockPreparedStatement)statements.get(index);
290            return null;
291        }
292        
293        /**
294         * Returns a {@link com.mockrunner.mock.jdbc.MockPreparedStatement} that was 
295         * created using a {@link com.mockrunner.mock.jdbc.MockConnection} by its SQL statement.
296         * If there are more than one {@link com.mockrunner.mock.jdbc.MockPreparedStatement}
297         * objects with the specified SQL, the first one will be returned.
298         * Please note that you can modify the search parameters with 
299         * {@link #setCaseSensitive}, {@link #setExactMatch} and {@link #setUseRegularExpressions}.
300         * @param sql the SQL statement used to create the <code>PreparedStatement</code>
301         * @return the <code>PreparedStatement</code> or <code>null</code>, if there is no macth
302         */
303        public MockPreparedStatement getPreparedStatement(String sql)
304        {
305            List list = getPreparedStatements(sql);
306            if(null != list && list.size() > 0)
307            {
308                return (MockPreparedStatement)list.get(0);
309            }
310            return null;
311        }
312        
313        /**
314         * Returns all {@link com.mockrunner.mock.jdbc.MockPreparedStatement} objects.
315         * @return the <code>List</code> of <code>PreparedStatement</code> objects
316         */
317        public List getPreparedStatements()
318        {
319            return mockFactory.getMockConnection().getPreparedStatementResultSetHandler().getPreparedStatements();
320        }
321        
322        /**
323         * Returns all {@link com.mockrunner.mock.jdbc.MockPreparedStatement} objects with
324         * the specified SQL statement as a <code>List</code>. If there are no matches, an empty
325         * <code>List</code> will be returned.
326         * Please note that you can modify the search parameters with 
327         * {@link #setCaseSensitive}, {@link #setExactMatch} and {@link #setUseRegularExpressions}.
328         * @param sql the SQL statement used to create the <code>PreparedStatement</code>
329         * @return the <code>List</code> of <code>PreparedStatement</code> objects
330         */
331        public List getPreparedStatements(String sql)
332        {
333            Map sqlStatements = mockFactory.getMockConnection().getPreparedStatementResultSetHandler().getPreparedStatementMap();
334            SQLStatementMatcher matcher = new SQLStatementMatcher(caseSensitive, exactMatch, useRegularExpressions);
335            return matcher.getMatchingObjects(sqlStatements, sql, true, false); 
336        }
337        
338        /**
339         * Returns a {@link com.mockrunner.mock.jdbc.MockCallableStatement} that was 
340         * created using a {@link com.mockrunner.mock.jdbc.MockConnection} by its index.
341         * @param index the index of the <code>CallableStatement</code>
342         * @return the <code>CallableStatement</code> or <code>null</code>, if there is no such
343         *         <code>CallableStatement</code>
344         */
345        public MockCallableStatement getCallableStatement(int index)
346        {
347            List statements = getCallableStatements();
348            if(index < statements.size()) return (MockCallableStatement)statements.get(index);
349            return null;
350        }
351        
352        /**
353         * Returns a {@link com.mockrunner.mock.jdbc.MockCallableStatement} that was 
354         * created using a {@link com.mockrunner.mock.jdbc.MockConnection} by its SQL statement.
355         * If there are more than one {@link com.mockrunner.mock.jdbc.MockCallableStatement}
356         * objects with the specified SQL, the first one will be returned.
357         * Please note that you can modify the search parameters with 
358         * {@link #setCaseSensitive}, {@link #setExactMatch} and {@link #setUseRegularExpressions}.
359         * @param sql the SQL statement used to create the <code>CallableStatement</code>
360         * @return the <code>CallableStatement</code> or <code>null</code>, if there is no macth
361         */
362        public MockCallableStatement getCallableStatement(String sql)
363        {
364            List list = getCallableStatements(sql);
365            if(null != list && list.size() > 0)
366            {
367                return (MockCallableStatement)list.get(0);
368            }
369            return null;
370        }
371        
372        /**
373         * Returns all {@link com.mockrunner.mock.jdbc.MockCallableStatement} objects.
374         * @return the <code>List</code> of <code>CallableStatement</code> objects
375         */
376        public List getCallableStatements()
377        {
378            return mockFactory.getMockConnection().getCallableStatementResultSetHandler().getCallableStatements();
379        }
380        
381        /**
382         * Returns all {@link com.mockrunner.mock.jdbc.MockCallableStatement} objects with
383         * the specified SQL statement as a <code>List</code>. 
384         * If there are no matches, an empty <code>List</code> will be returned. 
385         * Please note that you can modify the search parameters with 
386         * {@link #setCaseSensitive}, {@link #setExactMatch} and {@link #setUseRegularExpressions}.
387         * @param sql the SQL statement used to create the <code>CallableStatement</code>
388         * @return the <code>List</code> of <code>CallableStatement</code> objects
389         */
390        public List getCallableStatements(String sql)
391        {
392            Map sqlStatements = mockFactory.getMockConnection().getCallableStatementResultSetHandler().getCallableStatementMap();
393            SQLStatementMatcher matcher = new SQLStatementMatcher(caseSensitive, exactMatch, useRegularExpressions);
394            return matcher.getMatchingObjects(sqlStatements, sql, true, false); 
395        }
396        
397        /**
398         * Returns a parameter that was added to a <code>PreparedStatement</code>
399         * using its <code>set</code> methods. Simple data types are returned as
400         * the corresponsing wrapper type.
401         * @param statement the <code>PreparedStatement</code>
402         * @param indexOfParameter the index used to set the parameter
403         * @return the corresponding object
404         */
405        public Object getPreparedStatementParameter(PreparedStatement statement, int indexOfParameter)
406        {
407            if(null == statement) return null;
408            return ((MockPreparedStatement)statement).getParameter(indexOfParameter);
409        }
410        
411        /**
412         * Returns a parameter that was added to a <code>PreparedStatement</code>
413         * using its <code>set</code> methods. Uses the first <code>PreparedStatement</code>
414         * with the specified SQL statement. Simple data types are returned as
415         * the corresponsing wrapper type.
416         * @param sql the SQL statement
417         * @param indexOfParameter the index used to set the object
418         * @return the corresponding object
419         */
420        public Object getPreparedStatementParameter(String sql, int indexOfParameter)
421        {
422            return getPreparedStatementParameter(getPreparedStatement(sql), indexOfParameter);
423        }
424        
425        /**
426         * Returns an object that was added to a <code>PreparedStatement</code>
427         * using its <code>set</code> methods. Simple data types are returned as
428         * the corresponsing wrapper type.
429         * @param indexOfStatement the index of the statement
430         * @param indexOfParameter the index used to set the object
431         * @return the corresponding object
432         */
433        public Object getPreparedStatementParameter(int indexOfStatement, int indexOfParameter)
434        {
435            return getPreparedStatementParameter(getPreparedStatement(indexOfStatement), indexOfParameter);
436        }
437        
438        /**
439         * Returns a parameter that was added to a <code>CallableStatement</code>
440         * using its <code>set</code> methods. Simple data types are returned as
441         * the corresponsing wrapper type.
442         * @param statement the <code>CallableStatement</code>
443         * @param indexOfParameter the index used to set the parameter
444         * @return the corresponding object
445         */
446        public Object getCallableStatementParameter(CallableStatement statement, int indexOfParameter)
447        {
448            if(null == statement) return null;
449            return ((MockCallableStatement)statement).getParameter(indexOfParameter);
450        }
451    
452        /**
453         * Returns a parameter that was added to a <code>CallableStatement</code>
454         * using its <code>set</code> methods. Uses the first <code>CallableStatement</code>
455         * with the specified SQL statement. Simple data types are returned as
456         * the corresponsing wrapper type.
457         * @param sql the SQL statement
458         * @param indexOfParameter the index used to set the object
459         * @return the corresponding object
460         */
461        public Object getCallableStatementParameter(String sql, int indexOfParameter)
462        {
463            return getCallableStatementParameter(getCallableStatement(sql), indexOfParameter);
464        }
465    
466        /**
467         * Returns an object that was added to a <code>CallableStatement</code>
468         * using its <code>set</code> methods. Simple data types are returned as
469         * the corresponsing wrapper type.
470         * @param indexOfStatement the index of the statement
471         * @param indexOfParameter the index used to set the object
472         * @return the corresponding object
473         */
474        public Object getCallableStatementParameter(int indexOfStatement, int indexOfParameter)
475        {
476            return getCallableStatementParameter(getCallableStatement(indexOfStatement), indexOfParameter);
477        }
478        
479        /**
480         * Returns a parameter that was added to a <code>CallableStatement</code>
481         * using its <code>set</code> methods.
482         * @param statement the <code>CallableStatement</code>
483         * @param nameOfParameter the name of the parameter
484         * @return the corresponding object
485         */
486        public Object getCallableStatementParameter(CallableStatement statement, String nameOfParameter)
487        {
488            if(null == statement) return null;
489            return ((MockCallableStatement)statement).getParameter(nameOfParameter);
490        }
491    
492        /**
493         * Returns a parameter that was added to a <code>CallableStatement</code>
494         * using its <code>set</code> methods. Uses the first <code>CallableStatement</code>
495         * with the specified SQL statement.
496         * @param sql the SQL statement
497         * @param nameOfParameter the name of the parameter
498         * @return the corresponding object
499         */
500        public Object getCallableStatementParameter(String sql, String nameOfParameter)
501        {
502            return getCallableStatementParameter(getCallableStatement(sql), nameOfParameter);
503        }
504    
505        /**
506         * Returns an object that was added to a <code>CallableStatement</code>
507         * using its <code>set</code> methods.
508         * @param indexOfStatement the index of the statement
509         * @param nameOfParameter the name of the parameter
510         * @return the corresponding object
511         */
512        public Object getCallableStatementParameter(int indexOfStatement, String nameOfParameter)
513        {
514            return getCallableStatementParameter(getCallableStatement(indexOfStatement), nameOfParameter);
515        }
516        
517        /**
518         * Returns a list of all <code>Savepoint</code> objects.
519         * @return the <code>List</code> of {@link com.mockrunner.mock.jdbc.MockSavepoint} objects
520         */
521        public List getSavepoints()
522        {
523            return new ArrayList(mockFactory.getMockConnection().getSavepointMap().values());
524        }
525        
526        /**
527         * Returns the <code>Savepoint</code> with the specified index.
528         * The index is the number of the created <code>Savepoint</code>
529         * starting with 0 for the first <code>Savepoint</code>.
530         * @param index the index
531         * @return the {@link com.mockrunner.mock.jdbc.MockSavepoint}
532         */
533        public MockSavepoint getSavepoint(int index)
534        {
535            List savepoints = getSavepoints();
536            for(int ii = 0; ii < savepoints.size(); ii++)
537            {
538                MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(ii);
539                if(currentSavepoint.getNumber() == index) return currentSavepoint;
540            }
541            return null;
542        }
543        
544        /**
545         * Returns the first <code>Savepoint</code> with the specified name.
546         * Unnamed <code>Savepoint</code> objects get the name <i>""</i>.
547         * @param name the name
548         * @return the {@link com.mockrunner.mock.jdbc.MockSavepoint}
549         */
550        public MockSavepoint getSavepoint(String name)
551        {
552            List savepoints = getSavepoints();
553            for(int ii = 0; ii < savepoints.size(); ii++)
554            {
555                MockSavepoint currentSavepoint = (MockSavepoint)savepoints.get(ii);
556                try
557                {
558                    if(currentSavepoint.getSavepointName().equals(name)) return currentSavepoint;
559                }
560                catch(SQLException exc)
561                {
562                    throw new NestedApplicationException(exc);
563                }
564            }
565            return null;
566        }
567        
568        /**
569         * Verifies that an SQL statement was executed.
570         * @param sql the expected SQL string
571         * @throws VerifyFailedException if verification fails
572         */
573        public void verifySQLStatementExecuted(String sql)
574        {
575            SQLStatementMatcher matcher = new SQLStatementMatcher(caseSensitive, exactMatch, useRegularExpressions);
576            if(!matcher.contains(getExecutedSQLStatements(), sql, false))
577            {
578                throw new VerifyFailedException("Statement " + sql + " not executed.");
579            }
580        }
581        
582        /**
583         * Verifies that an SQL statement was not executed.
584         * @param sql the SQL string
585         * @throws VerifyFailedException if verification fails
586         */
587        public void verifySQLStatementNotExecuted(String sql)
588        {
589            SQLStatementMatcher matcher = new SQLStatementMatcher(caseSensitive, exactMatch, useRegularExpressions);
590            if(matcher.contains(getExecutedSQLStatements(), sql, false))
591            {
592                throw new VerifyFailedException("Statement " + sql + " was executed.");
593            }
594        }
595        
596            /**
597             * Verifies the number of parameters for the specified SQL statement.
598             * If more than one SQL statement is found, this method uses the
599             * first one. You can specify the number of the parameter set, i.e.
600             * if a <code>PreparedStatement</code> is reused several times, the
601             * number of the parameter sets corresponds to the actual parameters
602             * at a specific <code>execute</code> call.
603             * @param sql the SQL string
604             * @param indexOfParameterSet the number of the parameter set
605             * @param number the expected number of parameters
606             * @throws VerifyFailedException if verification fails
607             */
608            public void verifySQLStatementParameterNumber(String sql, int indexOfParameterSet, int number)
609            {
610                    Map actualParameterMap = verifyAndGetParametersForSQL(sql, indexOfParameterSet);
611                    if(actualParameterMap.size() != number)
612                    {
613                            throw new VerifyFailedException("Expected " + number + " parameter, actual " + actualParameterMap.size() + " parameter");
614                    }
615            }
616        
617            /**
618             * Verifies the parameters for the specified SQL statement.
619             * If more than one SQL statement is found, this method uses the
620             * first one. The parameter map must match in size and the
621             * parameters must be equal (by comparing them with
622             * {de.lv1871.util.ParameterUtil#compareParameter}).
623             * You can specify the number of the parameter set, i.e.
624             * if a <code>PreparedStatement</code> is reused several times, the
625             * number of the parameter sets corresponds to the actual parameters
626             * at a specific <code>execute</code> call.
627             * @param sql the SQL string
628             * @param indexOfParameterSet the number of the parameter set
629             * @param parameterMap the map of expected parameters
630             * @throws VerifyFailedException if verification fails
631             */
632            public void verifySQLStatementParameter(String sql, int indexOfParameterSet, Map parameterMap)
633            {
634                    verifySQLStatementParameterNumber(sql, indexOfParameterSet, parameterMap.size());
635                    Map actualParameterMap = verifyAndGetParametersForSQL(sql, indexOfParameterSet);
636                    Iterator keys = parameterMap.keySet().iterator();
637                    while(keys.hasNext())
638                    {
639                            Object nextKey = keys.next();
640                            Object nextExpectedParameter = parameterMap.get(nextKey);
641                            Object nextActualParameter = actualParameterMap.get(nextKey);
642                            if(null == nextActualParameter)
643                            {
644                                    throw new VerifyFailedException("No parameter " + nextKey + " found.");
645                            }
646                            if(!ParameterUtil.compareParameter(nextExpectedParameter, nextActualParameter))
647                            {
648                                    throw new VerifyFailedException("Expected " + nextExpectedParameter + " for parameter " + nextKey + ", but was " + nextActualParameter);
649                            }
650                    }
651            }
652            
653            /**
654             * Verifies the parameter for the specified SQL statement.
655             * If more than one SQL statement is found, this method uses the
656             * first one.
657             * You can specify the number of the parameter set, i.e.
658             * if a <code>PreparedStatement</code> is reused several times, the
659             * number of the parameter sets corresponds to the actual parameters
660             * at a specific <code>execute</code> call.
661             * @param sql the SQL string
662             * @param indexOfParameterSet the number of the parameter set
663             * @param indexOfParameter the index of the parameter
664             * @param expectedParameter the expected parameter
665             * @throws VerifyFailedException if verification fails
666             */
667            public void verifySQLStatementParameter(String sql, int indexOfParameterSet, int indexOfParameter, Object expectedParameter)
668            {
669                    Map actualParameterMap = verifyAndGetParametersForSQL(sql, indexOfParameterSet);
670                    Object actualParameter = actualParameterMap.get(new Integer(indexOfParameter));
671                    if(!ParameterUtil.compareParameter(expectedParameter, actualParameter))
672                    {
673                            throw new VerifyFailedException("Expected " + expectedParameter + " for parameter " + indexOfParameter + ", but was " + actualParameter);
674                    }
675            }
676            
677            /**
678             * Verifies the parameter for the specified SQL statement.
679             * If more than one SQL statement is found, this method uses the
680             * first one.
681             * You can specify the number of the parameter set, i.e.
682             * if a <code>PreparedStatement</code> is reused several times, the
683             * number of the parameter sets corresponds to the actual parameters
684             * at a specific <code>execute</code> call.
685             * @param sql the SQL string
686             * @param indexOfParameterSet the number of the parameter set
687             * @param nameOfParameter the name of the parameter
688             * @param expectedParameter the expected parameter
689             * @throws VerifyFailedException if verification fails
690             */
691            public void verifySQLStatementParameter(String sql, int indexOfParameterSet, String nameOfParameter, Object expectedParameter)
692            {
693                    Map actualParameterMap = verifyAndGetParametersForSQL(sql, indexOfParameterSet);
694                    Object actualParameter = actualParameterMap.get(nameOfParameter);
695                    if(!ParameterUtil.compareParameter(expectedParameter, actualParameter))
696                    {
697                            throw new VerifyFailedException("Expected " + expectedParameter + " for parameter " + nameOfParameter + ", but was " + actualParameter);
698                    }
699            }
700    
701            private Map verifyAndGetParametersForSQL(String sql, int indexOfParameterSet)
702            {
703                    verifySQLStatementExecuted(sql);
704                    SQLStatementMatcher matcher = new SQLStatementMatcher(caseSensitive, exactMatch, useRegularExpressions);
705                    List matchingParameterList = matcher.getMatchingObjects(getExecutedSQLStatementParameter(), sql, true, false);
706                    if(null == matchingParameterList || matchingParameterList.size() == 0)
707                    {
708                            throw new VerifyFailedException("No parameters for SQL " + sql + " found.");
709                    }
710                    ParameterSets actualParameterSets = (ParameterSets)matchingParameterList.get(0);
711                    if(null == actualParameterSets || indexOfParameterSet >= actualParameterSets.getNumberParameterSets())
712                    {
713                            throw new VerifyFailedException("Statement " + sql + " has no parameter set with index " + indexOfParameterSet);
714                    }
715                    return (Map)actualParameterSets.getParameterSet(indexOfParameterSet);
716            }
717        
718        /**
719         * Verifies that the connection is closed.
720         * @throws VerifyFailedException if verification fails
721         */
722        public void verifyConnectionClosed()
723        {
724            try
725            {
726                if(!mockFactory.getMockConnection().isClosed())
727                {
728                    throw new VerifyFailedException("Connection not closed.");
729                }
730            }
731            catch(SQLException exc)
732            {
733                throw new NestedApplicationException(exc);
734            }
735        }
736        
737        /**
738         * Verifies that all statements, all prepared statements and
739         * all callable statements are closed.
740         * @throws VerifyFailedException if verification fails
741         */
742        public void verifyAllStatementsClosed()
743        {
744            List statements = getStatements();
745            for(int ii = 0; ii < statements.size(); ii++)
746            {
747                MockStatement statement = (MockStatement)statements.get(ii);
748                if(!statement.isClosed())
749                {
750                    throw new VerifyFailedException("Statement with index " + ii + " not closed.");
751                }
752            }
753            statements = getPreparedStatements();
754            for(int ii = 0; ii < statements.size(); ii++)
755            {
756                MockPreparedStatement statement = (MockPreparedStatement)statements.get(ii);
757                if(!statement.isClosed())
758                {
759                    throw new VerifyFailedException("Prepared statement with index " + ii + " (SQL " + statement.getSQL() + ") not closed.");
760                }
761            }
762            statements = getCallableStatements();
763            for(int ii = 0; ii < statements.size(); ii++)
764            {
765                MockPreparedStatement statement = (MockCallableStatement)statements.get(ii);
766                if(!statement.isClosed())
767                {
768                    throw new VerifyFailedException("Callable statement with index " + ii + " (SQL " + statement.getSQL() + ") not closed.");
769                }
770            }
771        }
772        
773        /**
774         * Verifies that the <code>ResultSet</code> with the
775         * specified id is closed. Only recognizes <code>ResultSet</code>
776         * objects that were actually returned when executing a statement
777         * and that were explicitly closed. Implicit closed <code>ResultSet</code>
778         * objects (when closing a statement) are not recognized.
779         * @throws VerifyFailedException if verification fails
780         */
781        public void verifyResultSetClosed(String id)
782        {
783            MockResultSet resultSet = getReturnedResultSet(id);
784            if(null == resultSet)
785            {
786                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
787            }
788            if(!resultSet.isClosed())
789            {
790                throw new VerifyFailedException("ResultSet with id " + id + " not closed.");
791            }
792        }
793        
794        /**
795         * Verifies that the specified row of a <code>ResultSet</code> was
796         * inserted.
797         * @param resultSet the <code>ResultSet</code>
798         * @param number the number of the row
799         * @throws VerifyFailedException if verification fails
800         */
801        public void verifyResultSetRowInserted(MockResultSet resultSet, int number)
802        {
803            if(!resultSet.rowInserted(number))
804            {
805                throw new VerifyFailedException("Row number " + number + " of ResultSet " + resultSet.getId() + " not inserted.");
806            }
807        }
808        
809        /**
810         * Verifies that the specified row of a <code>ResultSet</code> was
811         * inserted.
812         * @param id the id of the <code>ResultSet</code>
813         * @param number the number of the row
814         * @throws VerifyFailedException if verification fails
815         */
816        public void verifyResultSetRowInserted(String id, int number)
817        {
818            MockResultSet resultSet = getReturnedResultSet(id);
819            if(null == resultSet)
820            {
821                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
822            }
823            verifyResultSetRowInserted(resultSet, number);
824        }
825        
826        /**
827         * Verifies that the specified row of a <code>ResultSet</code> was
828         * not inserted.
829         * @param resultSet the <code>ResultSet</code>
830         * @param number the number of the row
831         * @throws VerifyFailedException if verification fails
832         */
833        public void verifyResultSetRowNotInserted(MockResultSet resultSet, int number)
834        {
835            if(resultSet.rowInserted(number))
836            {
837                throw new VerifyFailedException("Row number " + number + " of ResultSet " + resultSet.getId() + " was inserted.");
838            }
839        }
840        
841        /**
842         * Verifies that the specified row of a <code>ResultSet</code> was
843         * not inserted.
844         * @param id the id of the <code>ResultSet</code>
845         * @param number the number of the row
846         * @throws VerifyFailedException if verification fails
847         */
848        public void verifyResultSetRowNotInserted(String id, int number)
849        {
850            MockResultSet resultSet = getReturnedResultSet(id);
851            if(null == resultSet)
852            {
853                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
854            }
855            verifyResultSetRowNotInserted(resultSet, number);
856        }
857        
858        /**
859         * Verifies that the specified row of a <code>ResultSet</code> was
860         * updated.
861         * @param resultSet the <code>ResultSet</code>
862         * @param number the number of the row
863         * @throws VerifyFailedException if verification fails
864         */
865        public void verifyResultSetRowUpdated(MockResultSet resultSet, int number)
866        {
867            if(!resultSet.rowUpdated(number))
868            {
869                throw new VerifyFailedException("Row number " + number + " of ResultSet " + resultSet.getId() + " not updated.");
870            }
871        }
872        
873        /**
874         * Verifies that the specified row of a <code>ResultSet</code> was
875         * updated.
876         * @param id the id of the <code>ResultSet</code>
877         * @param number the number of the row
878         * @throws VerifyFailedException if verification fails
879         */
880        public void verifyResultSetRowUpdated(String id, int number)
881        {
882            MockResultSet resultSet = getReturnedResultSet(id);
883            if(null == resultSet)
884            {
885                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
886            }
887            verifyResultSetRowUpdated(resultSet, number);
888        }
889        
890        /**
891         * Verifies that the specified row of a <code>ResultSet</code> was
892         * not updated.
893         * @param resultSet the <code>ResultSet</code>
894         * @param number the number of the row
895         * @throws VerifyFailedException if verification fails
896         */
897        public void verifyResultSetRowNotUpdated(MockResultSet resultSet, int number)
898        {
899            if(resultSet.rowUpdated(number))
900            {
901                throw new VerifyFailedException("Row number " + number + " of ResultSet " + resultSet.getId() + " was updated.");
902            }
903        }
904    
905        /**
906         * Verifies that the specified row of a <code>ResultSet</code> was
907         * not updated.
908         * @param id the id of the <code>ResultSet</code>
909         * @param number the number of the row
910         * @throws VerifyFailedException if verification fails
911         */
912        public void verifyResultSetRowNotUpdated(String id, int number)
913        {
914            MockResultSet resultSet = getReturnedResultSet(id);
915            if(null == resultSet)
916            {
917                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
918            }
919            verifyResultSetRowNotUpdated(resultSet, number);
920        }
921        
922        /**
923         * Verifies that the specified row of a <code>ResultSet</code> was
924         * deleted.
925         * @param resultSet the <code>ResultSet</code>
926         * @param number the number of the row
927         * @throws VerifyFailedException if verification fails
928         */
929        public void verifyResultSetRowDeleted(MockResultSet resultSet, int number)
930        {
931            if(!resultSet.rowDeleted(number))
932            {
933                throw new VerifyFailedException("Row number " + number + " of ResultSet " + resultSet.getId() + " not deleted.");
934            }
935        }
936        
937        /**
938         * Verifies that the specified row of a <code>ResultSet</code> was
939         * deleted.
940         * @param id the id of the <code>ResultSet</code>
941         * @param number the number of the row
942         * @throws VerifyFailedException if verification fails
943         */
944        public void verifyResultSetRowDeleted(String id, int number)
945        {
946            MockResultSet resultSet = getReturnedResultSet(id);
947            if(null == resultSet)
948            {
949                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
950            }
951            verifyResultSetRowDeleted(resultSet, number);
952        }
953        
954        /**
955         * Verifies that the specified row of a <code>ResultSet</code> was
956         * not deleted.
957         * @param resultSet the <code>ResultSet</code>
958         * @param number the number of the row
959         * @throws VerifyFailedException if verification fails
960         */
961        public void verifyResultSetRowNotDeleted(MockResultSet resultSet, int number)
962        {
963            if(resultSet.rowDeleted(number))
964            {
965                throw new VerifyFailedException("Row number " + number + " of ResultSet " + resultSet.getId() + " was deleted.");
966            }
967        }
968    
969        /**
970         * Verifies that the specified row of a <code>ResultSet</code> was
971         * not deleted.
972         * @param id the id of the <code>ResultSet</code>
973         * @param number the number of the row
974         * @throws VerifyFailedException if verification fails
975         */
976        public void verifyResultSetRowNotDeleted(String id, int number)
977        {
978            MockResultSet resultSet = getReturnedResultSet(id);
979            if(null == resultSet)
980            {
981                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
982            }
983            verifyResultSetRowNotDeleted(resultSet, number);
984        }
985        
986        /**
987         * Verifies that all <code>ResultSet</code> objects are closed.
988         * Only recognizes <code>ResultSet</code> * objects that were actually 
989         * returned when executing a statement and that were explicitly closed. 
990         * Implicit closed <code>ResultSet</code> objects (when closing a statement) 
991         * are not recognized.
992         * @throws VerifyFailedException if verification fails
993         */
994        public void verifyAllResultSetsClosed()
995        {
996            List allResultSets = getReturnedResultSets();
997            for(int ii = 0; ii < allResultSets.size(); ii++)
998            {
999                MockResultSet resultSet = (MockResultSet)allResultSets.get(ii);
1000                if(!resultSet.isClosed())
1001                {
1002                    throw new VerifyFailedException("ResultSet with id " + resultSet.getId() + " not closed.");
1003                }
1004            }
1005        }
1006        
1007        /**
1008         * Verifies that the changes were commited, i.e. the <code>commit</code>
1009         * method of <code>Connection</code> was at least called once.
1010         * Makes only sense, if the <code>Connection</code> is not in
1011         * autocommit mode. Automatic commits are not recognized.
1012         * @throws VerifyFailedException if verification fails
1013         */
1014        public void verifyCommitted()
1015        {
1016            int number = mockFactory.getMockConnection().getNumberCommits();
1017            if(number <= 0)
1018            {
1019                throw new VerifyFailedException("Connection received no commits.");
1020            }
1021        }
1022        
1023        /**
1024         * Verifies that the changes were not commited.
1025         * Makes only sense, if the <code>Connection</code> is not in
1026         * autocommit mode. Automatic commits are not recognized.
1027         * @throws VerifyFailedException if verification fails
1028         */
1029        public void verifyNotCommitted()
1030        {
1031            int number = mockFactory.getMockConnection().getNumberCommits();
1032            if(number > 0)
1033            {
1034                throw new VerifyFailedException("Connection was committed");
1035            }
1036        }
1037        
1038        /**
1039         * Verifies that the changes were rolled back, i.e. the <code>rollback</code>
1040         * method of <code>Connection</code> was at least called once.
1041         * Makes only sense, if the <code>Connection</code> is not in
1042         * autocommit mode.
1043         * @throws VerifyFailedException if verification fails
1044         */
1045        public void verifyRolledBack()
1046        {
1047            int number = mockFactory.getMockConnection().getNumberRollbacks();
1048            if(number <= 0)
1049            {
1050                throw new VerifyFailedException("Connection received no rollbacks.");
1051            }
1052        }
1053        
1054        /**
1055         * Verifies that the changes were not rolled back.
1056         * Makes only sense, if the <code>Connection</code> is not in
1057         * autocommit mode.
1058         * @throws VerifyFailedException if verification fails
1059         */
1060        public void verifyNotRolledBack()
1061        {
1062            int number = mockFactory.getMockConnection().getNumberRollbacks();
1063            if(number > 0)
1064            {
1065                throw new VerifyFailedException("Connection was rolled back.");
1066            }
1067        }
1068        
1069        /**
1070         * Verifies the number of <code>commit</code> calls.
1071         * Makes only sense, if the <code>Connection</code> is not in
1072         * autocommit mode.
1073         * @param number the expected number of commits
1074         * @throws VerifyFailedException if verification fails
1075         */
1076        public void verifyNumberCommits(int number)
1077        {
1078            int actualNumber = mockFactory.getMockConnection().getNumberCommits();
1079            if(actualNumber != number)
1080            {
1081                throw new VerifyFailedException("Connection received " + actualNumber + " commits, expected " + number);
1082            }
1083        }
1084        
1085        /**
1086         * Verifies the number of <code>rollback</code> calls.
1087         * Makes only sense, if the <code>Connection</code> is not in
1088         * autocommit mode.
1089         * @param number the expected number of rollbacks
1090         * @throws VerifyFailedException if verification fails
1091         */
1092        public void verifyNumberRollbacks(int number)
1093        {
1094            int actualNumber = mockFactory.getMockConnection().getNumberRollbacks();
1095            if(actualNumber != number)
1096            {
1097                throw new VerifyFailedException("Connection received " + actualNumber + " rollbacks, expected " + number);
1098            }
1099        }
1100        
1101        /**
1102         * Verifies the number of statements.
1103         * @param number the expected number
1104         * @throws VerifyFailedException if verification fails
1105         */
1106        public void verifyNumberStatements(int number)
1107        {
1108            verifyNumberStatements(number, getStatements());
1109        }
1110        
1111        /**
1112         * Verifies the number of prepared statements.
1113         * @param number the expected number
1114         * @throws VerifyFailedException if verification fails
1115         */
1116        public void verifyNumberPreparedStatements(int number)
1117        {
1118            verifyNumberStatements(number, getPreparedStatements());
1119        }
1120        
1121        /**
1122         * Verifies the number of prepared statements with the specified
1123         * SQL.
1124         * @param number the expected number
1125         * @param sql the SQL
1126         * @throws VerifyFailedException if verification fails
1127         */
1128        public void verifyNumberPreparedStatements(int number, String sql)
1129        {
1130            verifyNumberStatements(number, getPreparedStatements(sql));
1131        }
1132        
1133        /**
1134         * Verifies the number of callable statements.
1135         * @param number the expected number
1136         * @throws VerifyFailedException if verification fails
1137         */
1138        public void verifyNumberCallableStatements(int number)
1139        {
1140            verifyNumberStatements(number, getCallableStatements());
1141        }
1142    
1143        /**
1144         * Verifies the number of callable statements with the specified
1145         * SQL.
1146         * @param number the expected number
1147         * @param sql the SQL
1148         * @throws VerifyFailedException if verification fails
1149         */
1150        public void verifyNumberCallableStatements(int number, String sql)
1151        {
1152            verifyNumberStatements(number, getCallableStatements(sql));
1153        }
1154        
1155        private void verifyNumberStatements(int number, List statements)
1156        {
1157            if(null == statements || statements.size() == 0)
1158            {
1159                if(number == 0) return;
1160                throw new VerifyFailedException("Expected " + number + " statements, received 0 statements");
1161            }
1162            if(statements.size() != number)
1163            {
1164                throw new VerifyFailedException("Expected " + number + " statements, received " + statements.size()+ " statements");
1165            }
1166        }
1167        
1168        /**
1169         * Verifies that a statement is closed.
1170         * @param index the index of the statement
1171         * @throws VerifyFailedException if verification fails
1172         */
1173        public void verifyStatementClosed(int index)
1174        {
1175            MockStatement statement = getStatement(index);
1176            if(null == statement)
1177            {
1178                throw new VerifyFailedException("No statement with index " + index + " present.");
1179            }
1180            if(!statement.isClosed())
1181            {
1182                throw new VerifyFailedException("Statement with index " + index + " not closed.");
1183            }
1184        }
1185        
1186        /**
1187         * Verifies that a prepared statement is closed.
1188         * @param index the index of the prepared statement
1189         * @throws VerifyFailedException if verification fails
1190         */
1191        public void verifyPreparedStatementClosed(int index)
1192        {
1193            MockPreparedStatement statement = getPreparedStatement(index);
1194            if(null == statement)
1195            {
1196                throw new VerifyFailedException("No prepared statement with index " + index + " present.");
1197            }
1198            if(!statement.isClosed())
1199            {
1200                throw new VerifyFailedException("Prepared statement with index " + index + " not closed.");
1201            }
1202        }
1203        
1204        /**
1205         * Verifies that a prepared statement is closed.
1206         * @param sql the SQL statement
1207         * @throws VerifyFailedException if verification fails
1208         */
1209        public void verifyPreparedStatementClosed(String sql)
1210        {
1211            MockPreparedStatement statement = getPreparedStatement(sql);
1212            if(null == statement)
1213            {
1214                throw new VerifyFailedException("No prepared statement with SQL " + sql + " present.");
1215            }
1216            if(!statement.isClosed())
1217            {
1218                throw new VerifyFailedException("Prepared statement with SQL " + sql + " not closed.");
1219            }
1220        }
1221        
1222        /**
1223         * Verifies that a callable statement is closed.
1224         * @param index the index of the callable statement
1225         * @throws VerifyFailedException if verification fails
1226         */
1227        public void verifyCallableStatementClosed(int index)
1228        {
1229            MockCallableStatement statement = getCallableStatement(index);
1230            if(null == statement)
1231            {
1232                throw new VerifyFailedException("No callable statement with index " + index + " present.");
1233            }
1234            if(!statement.isClosed())
1235            {
1236                throw new VerifyFailedException("Callable statement with index " + index + " not closed.");
1237            }
1238        }
1239    
1240        /**
1241         * Verifies that a callable statement is closed.
1242         * @param sql the SQL statement
1243         * @throws VerifyFailedException if verification fails
1244         */
1245        public void verifyCallableStatementClosed(String sql)
1246        {
1247            MockCallableStatement statement = getCallableStatement(sql);
1248            if(null == statement)
1249            {
1250                throw new VerifyFailedException("No callable statement with SQL " + sql + " present.");
1251            }
1252            if(!statement.isClosed())
1253            {
1254                throw new VerifyFailedException("Callable statement with SQL " + sql + " not closed.");
1255            }
1256        }
1257        
1258        /**
1259         * Verifies that a row of a <code>ResultSet</code> is equal to the
1260         * entries in the specified <code>List</code>. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isRowEqual}.
1261         * You can verify the data of returned <code>ResultSet</code> objects if
1262         * the tested JDBC code makes updates.
1263         * @param resultSet the <code>ResultSet</code>
1264         * @param number the number of the row
1265         * @param rowData the row data
1266         * @throws VerifyFailedException if verification fails
1267         */
1268        public void verifyResultSetRow(MockResultSet resultSet, int number, List rowData)
1269        {
1270            if(null == resultSet.getRow(number))
1271            {
1272                throw new VerifyFailedException("ResultSet " + resultSet.getId() + " has no row " + number);
1273            }
1274            if(!resultSet.isRowEqual(number, rowData))
1275            {
1276                StringBuffer buffer = new StringBuffer("Actual row data:\n");
1277                StringUtil.appendObjectsAsString(buffer, resultSet.getRow(number));
1278                buffer.append("\n");
1279                buffer.append("Expected row data:\n");
1280                StringUtil.appendObjectsAsString(buffer, rowData);
1281                throw new VerifyFailedException("Mismatch in row data.\n" + buffer.toString());
1282            }
1283        }
1284        
1285        /**
1286         * Verifies that a row of a <code>ResultSet</code> is equal to the
1287         * entries in the specified array. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isRowEqual}.
1288         * You can verify the data of returned <code>ResultSet</code> objects if
1289         * the tested JDBC code makes updates.
1290         * @param resultSet the <code>ResultSet</code>
1291         * @param number the number of the row
1292         * @param rowData the row data
1293         * @throws VerifyFailedException if verification fails
1294         */
1295        public void verifyResultSetRow(MockResultSet resultSet, int number, Object[] rowData)
1296        {
1297            List dataList = ArrayUtil.getListFromObjectArray(rowData);
1298            verifyResultSetRow(resultSet, number, dataList);
1299        }
1300        
1301        /**
1302         * Verifies that a row of a <code>ResultSet</code> is equal to the
1303         * entries in the specified <code>List</code>. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isRowEqual}.
1304         * You can verify the data of returned <code>ResultSet</code> objects if
1305         * the tested JDBC code makes updates.
1306         * @param id the id of the <code>ResultSet</code>
1307         * @param number the number of the row
1308         * @param rowData the row data
1309         * @throws VerifyFailedException if verification fails
1310         */
1311        public void verifyResultSetRow(String id, int number, List rowData)
1312        {
1313            MockResultSet resultSet = getReturnedResultSet(id);
1314            if(null == resultSet)
1315            {
1316                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
1317            }
1318            verifyResultSetRow(resultSet, number, rowData);
1319        }
1320    
1321        /**
1322         * Verifies that a row of a <code>ResultSet</code> is equal to the
1323         * entries in the specified array. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isRowEqual}.
1324         * You can verify the data of returned <code>ResultSet</code> objects if
1325         * the tested JDBC code makes updates.
1326         * @param id the id of the <code>ResultSet</code>
1327         * @param number the number of the row
1328         * @param rowData the row data
1329         * @throws VerifyFailedException if verification fails
1330         */
1331        public void verifyResultSetRow(String id, int number, Object[] rowData)
1332        {
1333            List dataList = ArrayUtil.getListFromObjectArray(rowData);
1334            verifyResultSetRow(id, number, dataList);
1335        }
1336        
1337        /**
1338         * Verifies that a column of a <code>ResultSet</code> is equal to the
1339         * entries in the specified <code>List</code>. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(int, List)}.
1340         * You can verify the data of returned <code>ResultSet</code> objects if
1341         * the tested JDBC code makes updates.
1342         * @param resultSet the <code>ResultSet</code>
1343         * @param number the number of the column
1344         * @param columnData the column data
1345         * @throws VerifyFailedException if verification fails
1346         */
1347        public void verifyResultSetColumn(MockResultSet resultSet, int number, List columnData)
1348        {
1349            if(null == resultSet.getColumn(number))
1350            {
1351                throw new VerifyFailedException("ResultSet " + resultSet.getId() + " has no column " + number);
1352            }
1353            if(!resultSet.isColumnEqual(number, columnData))
1354            {
1355                StringBuffer buffer = new StringBuffer("Actual column data:\n");
1356                StringUtil.appendObjectsAsString(buffer, resultSet.getColumn(number));
1357                buffer.append("\n");
1358                buffer.append("Expected column data:\n");
1359                StringUtil.appendObjectsAsString(buffer, columnData);
1360                throw new VerifyFailedException("Mismatch in column data.\n" + buffer.toString());
1361            }
1362        }
1363    
1364        /**
1365         * Verifies that a column of a <code>ResultSet</code> is equal to the
1366         * entries in the specified array. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(int, List)}.
1367         * You can verify the data of returned <code>ResultSet</code> objects if
1368         * the tested JDBC code makes updates.
1369         * @param resultSet the <code>ResultSet</code>
1370         * @param number the number of the column
1371         * @param columnData the column data
1372         * @throws VerifyFailedException if verification fails
1373         */
1374        public void verifyResultSetColumn(MockResultSet resultSet, int number, Object[] columnData)
1375        {
1376            List dataList = ArrayUtil.getListFromObjectArray(columnData);
1377            verifyResultSetColumn(resultSet, number, dataList);
1378        }
1379    
1380        /**
1381         * Verifies that a column of a <code>ResultSet</code> is equal to the
1382         * entries in the specified <code>List</code>. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(int, List)}.
1383         * You can verify the data of returned <code>ResultSet</code> objects if
1384         * the tested JDBC code makes updates.
1385         * @param id the id of the <code>ResultSet</code>
1386         * @param number the number of the column
1387         * @param columnData the column data
1388         * @throws VerifyFailedException if verification fails
1389         */
1390        public void verifyResultSetColumn(String id, int number, List columnData)
1391        {
1392            MockResultSet resultSet = getReturnedResultSet(id);
1393            if(null == resultSet)
1394            {
1395                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
1396            }
1397            verifyResultSetColumn(resultSet, number, columnData);
1398        }
1399    
1400        /**
1401         * Verifies that a column of a <code>ResultSet</code> is equal to the
1402         * entries in the specified array. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(int, List)}.
1403         * You can verify the data of returned <code>ResultSet</code> objects if
1404         * the tested JDBC code makes updates.
1405         * @param id the id of the <code>ResultSet</code>
1406         * @param number the number of the column
1407         * @param columnData the column data
1408         * @throws VerifyFailedException if verification fails
1409         */
1410        public void verifyResultSetColumn(String id, int number, Object[] columnData)
1411        {
1412            List dataList = ArrayUtil.getListFromObjectArray(columnData);
1413            verifyResultSetColumn(id, number, dataList);
1414        }
1415        
1416        /**
1417         * Verifies that a column of a <code>ResultSet</code> is equal to the
1418         * entries in the specified <code>List</code>. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(String, List)}.
1419         * You can verify the data of returned <code>ResultSet</code> objects if
1420         * the tested JDBC code makes updates.
1421         * @param resultSet the <code>ResultSet</code>
1422         * @param name the name of the column
1423         * @param columnData the column data
1424         * @throws VerifyFailedException if verification fails
1425         */
1426        public void verifyResultSetColumn(MockResultSet resultSet, String name, List columnData)
1427        {
1428            if(null == resultSet.getColumn(name))
1429            {
1430                throw new VerifyFailedException("ResultSet " + resultSet.getId() + " has no column " + name);
1431            }
1432            if(!resultSet.isColumnEqual(name, columnData))
1433            {
1434                StringBuffer buffer = new StringBuffer("Actual column data:\n");
1435                StringUtil.appendObjectsAsString(buffer, resultSet.getColumn(name));
1436                buffer.append("\n");
1437                buffer.append("Expected column data:\n");
1438                StringUtil.appendObjectsAsString(buffer, columnData);
1439                throw new VerifyFailedException("Mismatch in column data.\n" + buffer.toString());
1440            }
1441        }
1442    
1443        /**
1444         * Verifies that a column of a <code>ResultSet</code> is equal to the
1445         * entries in the specified array. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(String, List)}.
1446         * You can verify the data of returned <code>ResultSet</code> objects if
1447         * the tested JDBC code makes updates.
1448         * @param resultSet the <code>ResultSet</code>
1449         * @param name the name of the column
1450         * @param columnData the column data
1451         * @throws VerifyFailedException if verification fails
1452         */
1453        public void verifyResultSetColumn(MockResultSet resultSet, String name, Object[] columnData)
1454        {
1455            List dataList = ArrayUtil.getListFromObjectArray(columnData);
1456            verifyResultSetColumn(resultSet, name, dataList);
1457        }
1458    
1459        /**
1460         * Verifies that a column of a <code>ResultSet</code> is equal to the
1461         * entries in the specified <code>List</code>. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(String, List)}.
1462         * You can verify the data of returned <code>ResultSet</code> objects if
1463         * the tested JDBC code makes updates.
1464         * @param id the id of the <code>ResultSet</code>
1465         * @param name the name of the column
1466         * @param columnData the column data
1467         * @throws VerifyFailedException if verification fails
1468         */
1469        public void verifyResultSetColumn(String id, String name, List columnData)
1470        {
1471            MockResultSet resultSet = getReturnedResultSet(id);
1472            if(null == resultSet)
1473            {
1474                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
1475            }
1476            verifyResultSetColumn(resultSet, name, columnData);
1477        }
1478    
1479        /**
1480         * Verifies that a column of a <code>ResultSet</code> is equal to the
1481         * entries in the specified array. Uses {@link com.mockrunner.mock.jdbc.MockResultSet#isColumnEqual(String, List)}.
1482         * You can verify the data of returned <code>ResultSet</code> objects if
1483         * the tested JDBC code makes updates.
1484         * @param id the id of the <code>ResultSet</code>
1485         * @param name the name of the column
1486         * @param columnData the column data
1487         * @throws VerifyFailedException if verification fails
1488         */
1489        public void verifyResultSetColumn(String id, String name, Object[] columnData)
1490        {
1491            List dataList = ArrayUtil.getListFromObjectArray(columnData);
1492            verifyResultSetColumn(id, name, dataList);
1493        }
1494        
1495        /**
1496         * Verifies that a <code>ResultSet</code> is equal to another one.
1497         * Compares all the rows with {@link com.mockrunner.mock.jdbc.MockResultSet#isEqual}.
1498         * @param source the source <code>ResultSet</code>
1499         * @param target the target <code>ResultSet</code>
1500         * @throws VerifyFailedException if verification fails
1501         */
1502        public void verifyResultSetEquals(MockResultSet source, MockResultSet target)
1503        {
1504            if(!source.isEqual(target))
1505            {
1506                StringBuffer buffer = new StringBuffer("Source data:\n");  
1507                buffer.append(source.toString());
1508                buffer.append("\n");
1509                buffer.append("Target data:\n");
1510                buffer.append(target.toString());
1511                throw new VerifyFailedException("Mismatch in ResultSet data.\n" + buffer.toString());
1512            }
1513        }
1514        
1515        /**
1516         * Verifies that a <code>ResultSet</code> is equal to another one.
1517         * Compares all the rows with {@link com.mockrunner.jdbc.ParameterUtil#compareParameter}.
1518         * @param id the id of the source <code>ResultSet</code>
1519         * @param target the target <code>ResultSet</code>
1520         * @throws VerifyFailedException if verification fails
1521         */
1522        public void verifyResultSetEquals(String id, MockResultSet target)
1523        {
1524            MockResultSet resultSet = getReturnedResultSet(id);
1525            if(null == resultSet)
1526            {
1527                throw new VerifyFailedException("ResultSet with id " + id + " not present.");
1528            }
1529            verifyResultSetEquals(resultSet, target);
1530        }
1531        
1532        /**
1533         * Verifies that a <code>PreparedStatement</code> with the specified 
1534         * SQL statement is present.
1535         * @param sql the SQL statement
1536         * @throws VerifyFailedException if verification fails
1537         */
1538        public void verifyPreparedStatementPresent(String sql)
1539        {
1540            if(null == getPreparedStatement(sql))
1541            {
1542                throw new VerifyFailedException("Prepared statement with SQL " +  sql + " present.");
1543            }
1544        }
1545        
1546        /**
1547         * Verifies that a <code>PreparedStatement</code> with the specified 
1548         * SQL statement is not present.
1549         * @param sql the SQL statement
1550         * @throws VerifyFailedException if verification fails
1551         */
1552        public void verifyPreparedStatementNotPresent(String sql)
1553        {
1554            if(null != getPreparedStatement(sql) )
1555            {
1556                throw new VerifyFailedException("Prepared statement with SQL " +  sql + " not present.");
1557            }
1558        }
1559        
1560        /**
1561         * Verifies that a <code>CallableStatement</code> with the specified 
1562         * SQL statement is present.
1563         * @param sql the SQL statement
1564         * @throws VerifyFailedException if verification fails
1565         */
1566        public void verifyCallableStatementPresent(String sql)
1567        {
1568            if(null == getCallableStatement(sql))
1569            {
1570                throw new VerifyFailedException("Callable statement with SQL " +  sql + " present.");
1571            }
1572        }
1573        
1574        /**
1575         * Verifies that a <code>CallableStatement</code> with the specified 
1576         * SQL statement is not present.
1577         * @param sql the SQL statement
1578         * @throws VerifyFailedException if verification fails
1579         */
1580        public void verifyCallableStatementNotPresent(String sql)
1581        {
1582            if(null != getCallableStatement(sql))
1583            {
1584                throw new VerifyFailedException("Callable statement with SQL " +  sql + " not present.");
1585            }
1586        }
1587        
1588        /**
1589         * Verifies that a parameter was added to a <code>PreparedStatement</code> with
1590         * the specified index.
1591         * @param statement the <code>PreparedStatement</code>
1592         * @param indexOfParameter the index used to set the object
1593         * @throws VerifyFailedException if verification fails
1594         */
1595        public void verifyPreparedStatementParameterPresent(PreparedStatement statement, int indexOfParameter)
1596        {
1597            if(null == getPreparedStatementParameter(statement, indexOfParameter))
1598            {
1599                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " not present.");
1600            }
1601        }
1602    
1603        /**
1604         * Verifies that a parameter was added to a <code>PreparedStatement</code> with
1605         * the specified index. Uses the first <code>PreparedStatement</code> with
1606         * the specified SQL.
1607         * @param sql the SQL statement of the <code>PreparedStatement</code>
1608         * @param indexOfParameter the index used to set the object
1609         * @throws VerifyFailedException if verification fails
1610         */
1611        public void verifyPreparedStatementParameterPresent(String sql, int indexOfParameter)
1612        {
1613            if(null == getPreparedStatementParameter(sql, indexOfParameter))
1614            {
1615                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " not present.");
1616            }
1617        }
1618        
1619        /**
1620         * Verifies that a parameter was added to a <code>PreparedStatement</code> with
1621         * the specified index.
1622         * @param indexOfStatement the index of the statement
1623         * @param indexOfParameter the index used to set the object
1624         * @throws VerifyFailedException if verification fails
1625         */
1626        public void verifyPreparedStatementParameterPresent(int indexOfStatement, int indexOfParameter)
1627        {
1628            if(null == getPreparedStatementParameter(indexOfStatement, indexOfParameter))
1629            {
1630                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " not present.");
1631            }
1632        }
1633        
1634        /**
1635         * Verifies that a parameter with the specified index is not present.
1636         * @param statement the <code>PreparedStatement</code>
1637         * @param indexOfParameter the index used to set the object
1638         * @throws VerifyFailedException if verification fails
1639         */
1640        public void verifyPreparedStatementParameterNotPresent(PreparedStatement statement, int indexOfParameter)
1641        {
1642            if(null != getPreparedStatementParameter(statement, indexOfParameter))
1643            {
1644                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " present.");
1645            }
1646        }
1647    
1648        /**
1649         * Verifies that a parameter with the specified index is not present.
1650         * Uses the first <code>PreparedStatement</code> with the specified SQL.
1651         * @param sql the SQL statement of the <code>PreparedStatement</code>
1652         * @param indexOfParameter the index used to set the object
1653         * @throws VerifyFailedException if verification fails
1654         */
1655        public void verifyPreparedStatementParameterNotPresent(String sql, int indexOfParameter)
1656        {
1657            if(null != getPreparedStatementParameter(sql, indexOfParameter))
1658            {
1659                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " present.");
1660            }
1661        }
1662    
1663        /**
1664         * Verifies that a parameter with the specified index is not present.
1665         * @param indexOfStatement the index of the statement
1666         * @param indexOfParameter the index used to set the object
1667         * @throws VerifyFailedException if verification fails
1668         */
1669        public void verifyPreparedStatementParameterNotPresent(int indexOfStatement, int indexOfParameter)
1670        {
1671            if(null != getPreparedStatementParameter(indexOfStatement, indexOfParameter))
1672            {
1673                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " present.");
1674            }
1675        }
1676        
1677        /**
1678         * Verifies that a parameter was added to a <code>CallableStatement</code> with
1679         * the specified index.
1680         * @param statement the <code>CallableStatement</code>
1681         * @param indexOfParameter the index used to set the object
1682         * @throws VerifyFailedException if verification fails
1683         */
1684        public void verifyCallableStatementParameterPresent(CallableStatement statement, int indexOfParameter)
1685        {
1686            if(null == getCallableStatementParameter(statement, indexOfParameter))
1687            {
1688                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " not present.");
1689            }
1690        }
1691    
1692        /**
1693         * Verifies that a parameter was added to a <code>CallableStatement</code> with
1694         * the specified index. Uses the first <code>CallableStatement</code> with
1695         * the specified SQL.
1696         * @param sql the SQL statement of the <code>CallableStatement</code>
1697         * @param indexOfParameter the index used to set the object
1698         * @throws VerifyFailedException if verification fails
1699         */
1700        public void verifyCallableStatementParameterPresent(String sql, int indexOfParameter)
1701        {
1702            if(null == getCallableStatementParameter(sql, indexOfParameter))
1703            {
1704                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " not present.");
1705            }
1706        }
1707        
1708        /**
1709         * Verifies that a parameter was added to a <code>CallableStatement</code> with
1710         * the specified index.
1711         * @param indexOfStatement the index of the statement
1712         * @param indexOfParameter the index used to set the object
1713         * @throws VerifyFailedException if verification fails
1714         */
1715        public void verifyCallableStatementParameterPresent(int indexOfStatement, int indexOfParameter)
1716        {
1717            if(null == getCallableStatementParameter(indexOfStatement, indexOfParameter))
1718            {
1719                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " not present.");
1720            }
1721        }
1722        
1723        /**
1724         * Verifies that a parameter with the specified index is not present.
1725         * @param statement the <code>CallableStatement</code>
1726         * @param indexOfParameter the index used to set the object
1727         * @throws VerifyFailedException if verification fails
1728         */
1729        public void verifyCallableStatementParameterNotPresent(CallableStatement statement, int indexOfParameter)
1730        {
1731            if(null != getCallableStatementParameter(statement, indexOfParameter))
1732            {
1733                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " present.");
1734            }
1735        }
1736    
1737        /**
1738         * Verifies that a parameter with the specified index is not present.
1739         * Uses the first <code>CallableStatement</code> with the specified SQL.
1740         * @param sql the SQL statement of the <code>CallableStatement</code>
1741         * @param indexOfParameter the index used to set the object
1742         * @throws VerifyFailedException if verification fails
1743         */
1744        public void verifyCallableStatementParameterNotPresent(String sql, int indexOfParameter)
1745        {
1746            if(null != getCallableStatementParameter(sql, indexOfParameter))
1747            {
1748                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " present.");
1749            }
1750        }
1751    
1752        /**
1753         * Verifies that a parameter with the specified index is not present.
1754         * @param indexOfStatement the index of the statement
1755         * @param indexOfParameter the index used to set the object
1756         * @throws VerifyFailedException if verification fails
1757         */
1758        public void verifyCallableStatementParameterNotPresent(int indexOfStatement, int indexOfParameter)
1759        {
1760            if(null != getCallableStatementParameter(indexOfStatement, indexOfParameter))
1761            {
1762                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " present.");
1763            }
1764        }
1765        
1766        /**
1767         * Verifies that a parameter was added to a <code>CallableStatement</code> with
1768         * the specified index.
1769         * @param statement the <code>CallableStatement</code>
1770         * @param nameOfParameter the name of the parameter
1771         * @throws VerifyFailedException if verification fails
1772         */
1773        public void verifyCallableStatementParameterPresent(CallableStatement statement, String nameOfParameter)
1774        {
1775            if(null == getCallableStatementParameter(statement, nameOfParameter))
1776            {
1777                throw new VerifyFailedException("Callable statement parameter with index " + nameOfParameter + " not present.");
1778            }
1779        }
1780    
1781        /**
1782         * Verifies that a parameter was added to a <code>CallableStatement</code> with
1783         * the specified index. Uses the first <code>CallableStatement</code> with
1784         * the specified SQL.
1785         * @param sql the SQL statement of the <code>CallableStatement</code>
1786         * @param nameOfParameter the name of the parameter
1787         * @throws VerifyFailedException if verification fails
1788         */
1789        public void verifyCallableStatementParameterPresent(String sql, String nameOfParameter)
1790        {
1791            if(null == getCallableStatementParameter(sql, nameOfParameter))
1792            {
1793                throw new VerifyFailedException("Callable statement parameter with index " + nameOfParameter + " not present.");
1794            }
1795        }
1796        
1797        /**
1798         * Verifies that a parameter was added to a <code>CallableStatement</code> with
1799         * the specified index.
1800         * @param indexOfStatement the index of the statement
1801         * @param nameOfParameter the name of the parameter
1802         * @throws VerifyFailedException if verification fails
1803         */
1804        public void verifyCallableStatementParameterPresent(int indexOfStatement, String nameOfParameter)
1805        {
1806            if(null == getCallableStatementParameter(indexOfStatement, nameOfParameter))
1807            {
1808                throw new VerifyFailedException("Callable statement parameter with index " + nameOfParameter + " not present.");
1809            }
1810        }
1811        
1812        /**
1813         * Verifies that a parameter with the specified index is not present.
1814         * @param statement the <code>CallableStatement</code>
1815         * @param nameOfParameter the name of the parameter
1816         * @throws VerifyFailedException if verification fails
1817         */
1818        public void verifyCallableStatementParameterNotPresent(CallableStatement statement, String nameOfParameter)
1819        {
1820            if(null != getCallableStatementParameter(statement, nameOfParameter))
1821            {
1822                throw new VerifyFailedException("Callable statement parameter with index " + nameOfParameter + " present.");
1823            }
1824        }
1825    
1826        /**
1827         * Verifies that a parameter with the specified index is not present.
1828         * Uses the first <code>CallableStatement</code> with the specified SQL.
1829         * @param sql the SQL statement of the <code>CallableStatement</code>
1830         * @param nameOfParameter the name of the parameter
1831         * @throws VerifyFailedException if verification fails
1832         */
1833        public void verifyCallableStatementParameterNotPresent(String sql, String nameOfParameter)
1834        {
1835            if(null != getCallableStatementParameter(sql, nameOfParameter))
1836            {
1837                throw new VerifyFailedException("Callable statement parameter with index " + nameOfParameter + " present.");
1838            }
1839        }
1840    
1841        /**
1842         * Verifies that a parameter with the specified index is not present.
1843         * @param indexOfStatement the index of the statement
1844         * @param nameOfParameter the name of the parameter
1845         * @throws VerifyFailedException if verification fails
1846         */
1847        public void verifyCallableStatementParameterNotPresent(int indexOfStatement, String nameOfParameter)
1848        {
1849            if(null != getCallableStatementParameter(indexOfStatement, nameOfParameter))
1850            {
1851                throw new VerifyFailedException("Callable statement parameter with index " + nameOfParameter + " present.");
1852            }
1853        }
1854        
1855        /**
1856         * Verifies that a parameter from the specified <code>PreparedStatement</code> is equal
1857         * to the specified object. Please use the corresponding wrapper type for
1858         * primitive data types.
1859         * @param statement the <code>PreparedStatement</code>
1860         * @param indexOfParameter the index used to set the object
1861         * @param object the expected object
1862         * @throws VerifyFailedException if verification fails
1863         */
1864        public void verifyPreparedStatementParameter(PreparedStatement statement, int indexOfParameter, Object object)
1865        {
1866            verifyPreparedStatementParameterPresent(statement, indexOfParameter);
1867            Object actualObject = getPreparedStatementParameter(statement, indexOfParameter);
1868            if(!ParameterUtil.compareParameter(actualObject, object))
1869            {
1870                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " has the value " +
1871                                                 actualObject.toString() + ", expected " + object.toString());
1872            }
1873        }
1874        
1875        /**
1876         * Verifies that a parameter from the <code>PreparedStatement</code> with the
1877         * specified SQL statement is equal to the specified object.
1878         * Uses the first <code>PreparedStatement</code> with the specified SQL.
1879         * Please use the corresponding wrapper type for primitive data types.
1880         * @param sql the SQL statement of the <code>PreparedStatement</code>
1881         * @param indexOfParameter the index used to set the object
1882         * @param object the expected object
1883         * @throws VerifyFailedException if verification fails
1884         */
1885        public void verifyPreparedStatementParameter(String sql, int indexOfParameter, Object object)
1886        {
1887            verifyPreparedStatementParameterPresent(sql, indexOfParameter);
1888            Object actualObject = getPreparedStatementParameter(sql, indexOfParameter);
1889            if(!ParameterUtil.compareParameter(actualObject, object))
1890            {
1891                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " has the value " +
1892                                                 actualObject.toString() + ", expected " + object.toString());
1893            }
1894        }
1895        
1896        /**
1897         * Verifies that a parameter from the <code>PreparedStatement</code> with the
1898         * specified SQL statement is equal to the specified object.
1899         * Please use the corresponding wrapper type for primitive data types.
1900         * @param indexOfStatement the index of the statement
1901         * @param indexOfParameter the index used to set the object
1902         * @param object the expected object
1903         * @throws VerifyFailedException if verification fails
1904         */
1905        public void verifyPreparedStatementParameter(int indexOfStatement, int indexOfParameter, Object object)
1906        {
1907            verifyPreparedStatementParameterPresent(indexOfStatement, indexOfParameter);
1908            Object actualObject = getPreparedStatementParameter(indexOfStatement, indexOfParameter);
1909            if(!ParameterUtil.compareParameter(actualObject, object))
1910            {
1911                throw new VerifyFailedException("Prepared statement parameter with index " + indexOfParameter + " has the value " +
1912                                                 actualObject.toString() + ", expected " + object.toString());
1913            }
1914        }
1915        
1916        /**
1917         * Verifies that a parameter from the specified <code>CallableStatement</code> is equal
1918         * to the specified object. Please use the corresponding wrapper type 
1919         * for primitive data types.
1920         * @param statement the <code>CallableStatement</code>
1921         * @param indexOfParameter the index used to set the object
1922         * @param object the expected object
1923         * @throws VerifyFailedException if verification fails
1924         */
1925        public void verifyCallableStatementParameter(CallableStatement statement, int indexOfParameter, Object object)
1926        {
1927            verifyCallableStatementParameterPresent(statement, indexOfParameter);
1928            Object actualObject = getCallableStatementParameter(statement, indexOfParameter);
1929            if(!ParameterUtil.compareParameter(actualObject, object))
1930            {
1931                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " has the value " +
1932                                                 actualObject.toString() + ", expected " + object.toString());
1933            }
1934        }
1935        
1936        /**
1937         * Verifies that a parameter from the <code>CallableStatement</code> with the
1938         * specified SQL statement is equal to the specified object.
1939         * Uses the first <code>CallableStatement</code> with the specified SQL.
1940         * Please use the corresponding wrapper type for primitive data types.
1941         * @param sql the SQL statement of the <code>CallableStatement</code>
1942         * @param indexOfParameter the index used to set the object
1943         * @param object the expected object
1944         * @throws VerifyFailedException if verification fails
1945         */
1946        public void verifyCallableStatementParameter(String sql, int indexOfParameter, Object object)
1947        {
1948            verifyCallableStatementParameterPresent(sql, indexOfParameter);
1949            Object actualObject = getCallableStatementParameter(sql, indexOfParameter);
1950            if(!ParameterUtil.compareParameter(actualObject, object))
1951            {
1952                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " has the value " +
1953                                                 actualObject.toString() + ", expected " + object.toString());
1954            }
1955        }
1956        
1957        /**
1958         * Verifies that a parameter from the <code>CallableStatement</code> with the
1959         * specified SQL statement is equal to the specified object.
1960         * Please use the corresponding wrapper type for primitive data types.
1961         * @param indexOfStatement the index of the statement
1962         * @param indexOfParameter the index used to set the object
1963         * @param object the expected object
1964         * @throws VerifyFailedException if verification fails
1965         */
1966        public void verifyCallableStatementParameter(int indexOfStatement, int indexOfParameter, Object object)
1967        {
1968            verifyCallableStatementParameterPresent(indexOfStatement, indexOfParameter);
1969            Object actualObject = getCallableStatementParameter(indexOfStatement, indexOfParameter);
1970            if(!ParameterUtil.compareParameter(actualObject, object))
1971            {
1972                throw new VerifyFailedException("Callable statement parameter with index " + indexOfParameter + " has the value " +
1973                                                 actualObject.toString() + ", expected " + object.toString());
1974            }
1975        }
1976        
1977        /**
1978         * Verifies that a parameter from the specified <code>CallableStatement</code> is equal
1979         * to the specified object. Please use the corresponding wrapper type 
1980         * for primitive data types.
1981         * @param statement the <code>CallableStatement</code>
1982         * @param nameOfParameter the name of the parameter
1983         * @param object the expected object
1984         * @throws VerifyFailedException if verification fails
1985         */
1986        public void verifyCallableStatementParameter(CallableStatement statement, String nameOfParameter, Object object)
1987        {
1988            verifyCallableStatementParameterPresent(statement, nameOfParameter);
1989            Object actualObject = getCallableStatementParameter(statement, nameOfParameter);
1990            if(!ParameterUtil.compareParameter(actualObject, object))
1991            {
1992                throw new VerifyFailedException("Callable statement parameter with name " + nameOfParameter + " has the value " +
1993                                                 actualObject.toString() + ", expected " + object.toString());
1994            }
1995        }
1996        
1997        /**
1998         * Verifies that a parameter from the <code>CallableStatement</code> with the
1999         * specified SQL statement is equal to the specified object.
2000         * Uses the first <code>CallableStatement</code> with the specified SQL.
2001         * Please use the corresponding wrapper type for primitive data types.
2002         * @param sql the SQL statement of the <code>CallableStatement</code>
2003         * @param nameOfParameter the name of the parameter
2004         * @param object the expected object
2005         * @throws VerifyFailedException if verification fails
2006         */
2007        public void verifyCallableStatementParameter(String sql, String nameOfParameter, Object object)
2008        {
2009            verifyCallableStatementParameterPresent(sql, nameOfParameter);
2010            Object actualObject = getCallableStatementParameter(sql, nameOfParameter);
2011            if(!ParameterUtil.compareParameter(actualObject, object))
2012            {
2013                throw new VerifyFailedException("Callable statement parameter with name " + nameOfParameter + " has the value " +
2014                                                 actualObject.toString() + ", expected " + object.toString());
2015            }
2016        }
2017        
2018        /**
2019         * Verifies that a parameter from the <code>CallableStatement</code> with the
2020         * specified SQL statement is equal to the specified object.
2021         * Please use the corresponding wrapper type for primitive data types.
2022         * @param indexOfStatement the index of the statement
2023         * @param nameOfParameter the name of the parameter
2024         * @param object the expected object
2025         * @throws VerifyFailedException if verification fails
2026         */
2027        public void verifyCallableStatementParameter(int indexOfStatement, String nameOfParameter, Object object)
2028        {
2029            verifyCallableStatementParameterPresent(indexOfStatement, nameOfParameter);
2030            Object actualObject = getCallableStatementParameter(indexOfStatement, nameOfParameter);
2031            if(!ParameterUtil.compareParameter(actualObject, object))
2032            {
2033                throw new VerifyFailedException("Callable statement parameter with name " + nameOfParameter + " has the value " +
2034                                                 actualObject.toString() + ", expected " + object.toString());
2035            }
2036        }
2037        
2038        /**
2039         * Verifies that an out parameter was registered on the specified
2040         * <code>CallableStatement</code>.
2041         * @param statement the <code>CallableStatement</code>
2042         * @param indexOfParameter the index of the parameter
2043         * @throws VerifyFailedException if verification fails
2044         */
2045        public void verifyCallableStatementOutParameterRegistered(CallableStatement statement, int indexOfParameter)
2046        {
2047            if(!((MockCallableStatement)statement).isOutParameterRegistered(indexOfParameter))
2048            {
2049                throw new VerifyFailedException("Out parameter with index " + indexOfParameter +
2050                                                " not registered in callable statement ");
2051            }
2052        }
2053    
2054        /**
2055         * Verifies that an out parameter was registered on the
2056         * <code>CallableStatement</code> with the specified SQL.
2057         * @param sql the SQL statement
2058         * @param indexOfParameter the index of the parameter
2059         * @throws VerifyFailedException if verification fails
2060         */
2061        public void verifyCallableStatementOutParameterRegistered(String sql, int indexOfParameter)
2062        {
2063            MockCallableStatement statement = getCallableStatement(sql);
2064            if(null == statement)
2065            {
2066                throw new VerifyFailedException("No callable statement " + sql + " present");
2067            }
2068            if(!statement.isOutParameterRegistered(indexOfParameter))
2069            {
2070                throw new VerifyFailedException("Out parameter with index " + indexOfParameter +
2071                                                " not registered in callable statement " + sql);
2072            }
2073        }
2074    
2075        /**
2076         * Verifies that an out parameter was registered on the
2077         * <code>CallableStatement</code> with the specified index.
2078         * @param indexOfStatement the index of the <code>CallableStatement</code>
2079         * @param indexOfParameter the index of the parameter
2080         * @throws VerifyFailedException if verification fails
2081         */
2082        public void verifyCallableStatementOutParameterRegistered(int indexOfStatement, int indexOfParameter)
2083        {
2084            MockCallableStatement statement = getCallableStatement(indexOfStatement);
2085            if(null == statement)
2086            {
2087                throw new VerifyFailedException("No callable statement with index " + indexOfStatement + " present");
2088            }
2089            if(!statement.isOutParameterRegistered(indexOfParameter))
2090            {
2091                throw new VerifyFailedException("Out parameter with index " + indexOfParameter +
2092                                                " not registered in callable statement with index " + indexOfStatement);
2093            }
2094        }
2095        
2096        /**
2097         * Verifies that an out parameter was registered on the specified
2098         * <code>CallableStatement</code>.
2099         * @param statement the <code>CallableStatement</code>
2100         * @param nameOfParameter the name of the parameter
2101         * @throws VerifyFailedException if verification fails
2102         */
2103        public void verifyCallableStatementOutParameterRegistered(CallableStatement statement, String nameOfParameter)
2104        {
2105            if(!((MockCallableStatement)statement).isOutParameterRegistered(nameOfParameter))
2106            {
2107                throw new VerifyFailedException("Out parameter with name " + nameOfParameter +
2108                                                " not registered in callable statement ");
2109            }
2110        }
2111        
2112        /**
2113         * Verifies that an out parameter was registered on the
2114         * <code>CallableStatement</code> with the specified SQL.
2115         * @param sql the SQL statement
2116         * @param nameOfParameter the name of the parameter
2117         * @throws VerifyFailedException if verification fails
2118         */
2119        public void verifyCallableStatementOutParameterRegistered(String sql, String nameOfParameter)
2120        {
2121            MockCallableStatement statement = getCallableStatement(sql);
2122            if(null == statement)
2123            {
2124                throw new VerifyFailedException("No callable statement " + sql + " present");
2125            }
2126            if(!statement.isOutParameterRegistered(nameOfParameter))
2127            {
2128                throw new VerifyFailedException("Out parameter with name " + nameOfParameter +
2129                                                " not registered in callable statement " + sql);
2130            }
2131        }
2132        
2133        /**
2134         * Verifies that an out parameter was registered on the
2135         * <code>CallableStatement</code> with the specified index.
2136         * @param indexOfStatement the index of the <code>CallableStatement</code>
2137         * @param nameOfParameter the name of the parameter
2138         * @throws VerifyFailedException if verification fails
2139         */
2140        public void verifyCallableStatementOutParameterRegistered(int indexOfStatement, String nameOfParameter)
2141        {
2142            MockCallableStatement statement = getCallableStatement(indexOfStatement);
2143            if(null == statement)
2144            {
2145                throw new VerifyFailedException("No callable statement with index " + indexOfStatement + " present");
2146            }
2147            if(!statement.isOutParameterRegistered(nameOfParameter))
2148            {
2149                throw new VerifyFailedException("Out parameter with name " + nameOfParameter +
2150                                                " not registered in callable statement with index " + indexOfStatement);
2151            }
2152        }
2153        
2154        /**
2155         * Verifies that a <code>Savepoint</code> with the specified index
2156         * is present. The index is the number of the created <code>Savepoint</code>
2157         * starting with 0 for the first <code>Savepoint</code>.
2158         * @param index the index of the <code>Savepoint</code>
2159         */
2160        public void verifySavepointPresent(int index)
2161        {
2162            MockSavepoint savepoint = getSavepoint(index);
2163            if(null == savepoint)
2164            {
2165                throw new VerifyFailedException("No savepoint with index " + index + " present.");
2166            }
2167        }
2168        
2169        /**
2170         * Verifies that a <code>Savepoint</code> with the specified name
2171         * is present.
2172         * @param name the name of the <code>Savepoint</code>
2173         */
2174        public void verifySavepointPresent(String name)
2175        {
2176            MockSavepoint savepoint = getSavepoint(name);
2177            if(null == savepoint)
2178            {
2179                throw new VerifyFailedException("No savepoint with name " + name + " present.");
2180            }
2181        }
2182        
2183        /**
2184         * Verifies that the <code>Savepoint</code> with the specified index
2185         * is released. The index is the number of the created <code>Savepoint</code>
2186         * starting with 0 for the first <code>Savepoint</code>.
2187         * @param index the index of the <code>Savepoint</code>
2188         */
2189        public void verifySavepointReleased(int index)
2190        {
2191            verifySavepointPresent(index);
2192            if(!getSavepoint(index).isReleased())
2193            {
2194                throw new VerifyFailedException("Savepoint with index " + index + " not released.");
2195            }
2196        }
2197        
2198        /**
2199         * Verifies that the <code>Savepoint</code> with the specified name
2200         * is released.
2201         * @param name the name of the <code>Savepoint</code>
2202         */
2203        public void verifySavepointReleased(String name)
2204        {
2205            verifySavepointPresent(name);
2206            if(!getSavepoint(name).isReleased())
2207            {
2208                throw new VerifyFailedException("Savepoint with name " + name + " not released.");
2209            }
2210        }
2211        
2212        /**
2213         * Verifies that the <code>Savepoint</code> with the specified index
2214         * is not released. The index is the number of the created <code>Savepoint</code>
2215         * starting with 0 for the first <code>Savepoint</code>.
2216         * @param index the index of the <code>Savepoint</code>
2217         */
2218        public void verifySavepointNotReleased(int index)
2219        {
2220            verifySavepointPresent(index);
2221            if(getSavepoint(index).isReleased())
2222            {
2223                throw new VerifyFailedException("Savepoint with index " + index + " is released.");
2224            }
2225        }
2226    
2227        /**
2228         * Verifies that the <code>Savepoint</code> with the specified name
2229         * is not released.
2230         * @param name the name of the <code>Savepoint</code>
2231         */
2232        public void verifySavepointNotReleased(String name)
2233        {
2234            verifySavepointPresent(name);
2235            if(getSavepoint(name).isReleased())
2236            {
2237                throw new VerifyFailedException("Savepoint with name " + name + " is released.");
2238            }
2239        }
2240        
2241        /**
2242         * Verifies that the <code>Savepoint</code> with the specified index
2243         * is rolled back. The index is the number of the created <code>Savepoint</code>
2244         * starting with 0 for the first <code>Savepoint</code>.
2245         * @param index the index of the <code>Savepoint</code>
2246         */
2247        public void verifySavepointRolledBack(int index)
2248        {
2249            verifySavepointPresent(index);
2250            if(!getSavepoint(index).isRolledBack())
2251            {
2252                throw new VerifyFailedException("Savepoint with index " + index + " not rolled back.");
2253            }
2254        }
2255    
2256        /**
2257         * Verifies that the <code>Savepoint</code> with the specified name
2258         * is rolled back.
2259         * @param name the name of the <code>Savepoint</code>
2260         */
2261        public void verifySavepointRolledBack(String name)
2262        {
2263            verifySavepointPresent(name);
2264            if(!getSavepoint(name).isRolledBack())
2265            {
2266                throw new VerifyFailedException("Savepoint with name " + name + " not rolled back.");
2267            }
2268        }
2269        
2270        /**
2271         * Verifies that the <code>Savepoint</code> with the specified index
2272         * is not rolled back. The index is the number of the created <code>Savepoint</code>
2273         * starting with 0 for the first <code>Savepoint</code>.
2274         * @param index the index of the <code>Savepoint</code>
2275         */
2276        public void verifySavepointNotRolledBack(int index)
2277        {
2278            verifySavepointPresent(index);
2279            if(getSavepoint(index).isRolledBack())
2280            {
2281                throw new VerifyFailedException("Savepoint with index " + index + " is rolled back.");
2282            }
2283        }
2284    
2285        /**
2286         * Verifies that the <code>Savepoint</code> with the specified name
2287         * is not rolled back.
2288         * @param name the name of the <code>Savepoint</code>
2289         */
2290        public void verifySavepointNotRolledBack(String name)
2291        {
2292            verifySavepointPresent(name);
2293            if(getSavepoint(name).isRolledBack())
2294            {
2295                throw new VerifyFailedException("Savepoint with name " + name + " is rolled back.");
2296            }
2297        }
2298        
2299        /**
2300         * @deprecated use {@link #verifySavepointRolledBack(int)}
2301         */
2302        public void verifySavepointRollbacked(int index)
2303        {
2304            verifySavepointRolledBack(index);
2305        }
2306    
2307        /**
2308         * @deprecated use {@link #verifySavepointRolledBack(String)}
2309         */
2310        public void verifySavepointRollbacked(String name)
2311        {
2312            verifySavepointRolledBack(name);
2313        }
2314    
2315        /**
2316         * @deprecated use {@link #verifySavepointNotRolledBack(int)}
2317         */
2318        public void verifySavepointNotRollbacked(int index)
2319        {
2320            verifySavepointNotRolledBack(index);
2321        }
2322    
2323        /**
2324         * @deprecated use {@link #verifySavepointNotRolledBack(String)}
2325         */
2326        public void verifySavepointNotRollbacked(String name)
2327        {
2328            verifySavepointNotRolledBack(name);
2329        }
2330    }