KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > net > sf > hajdbc > sql > TestResultSet


1 /*
2  * HA-JDBC: High-Availability JDBC
3  * Copyright (c) 2004-2006 Paul Ferraro
4  *
5  * This library is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU Lesser General Public License as published by the
7  * Free Software Foundation; either version 2.1 of the License, or (at your
8  * option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful, but WITHOUT
11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
13  * for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with this library; if not, write to the Free Software Foundation,
17  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18  *
19  * Contact: ferraro@users.sourceforge.net
20  */

21 package net.sf.hajdbc.sql;
22
23 import java.io.ByteArrayInputStream JavaDoc;
24 import java.io.File JavaDoc;
25 import java.io.InputStream JavaDoc;
26 import java.io.Reader JavaDoc;
27 import java.io.StringReader JavaDoc;
28 import java.math.BigDecimal JavaDoc;
29 import java.net.MalformedURLException JavaDoc;
30 import java.net.URL JavaDoc;
31 import java.sql.Array JavaDoc;
32 import java.sql.Blob JavaDoc;
33 import java.sql.Clob JavaDoc;
34 import java.sql.Date JavaDoc;
35 import java.sql.Ref JavaDoc;
36 import java.sql.ResultSetMetaData JavaDoc;
37 import java.sql.SQLException JavaDoc;
38 import java.sql.SQLWarning JavaDoc;
39 import java.sql.Time JavaDoc;
40 import java.sql.Timestamp JavaDoc;
41 import java.sql.Types JavaDoc;
42 import java.util.Calendar JavaDoc;
43 import java.util.Collections JavaDoc;
44 import java.util.List JavaDoc;
45 import java.util.Map JavaDoc;
46 import java.util.concurrent.ExecutorService JavaDoc;
47 import java.util.concurrent.Executors JavaDoc;
48 import java.util.concurrent.locks.Lock JavaDoc;
49
50 import net.sf.hajdbc.Balancer;
51 import net.sf.hajdbc.Database;
52 import net.sf.hajdbc.DatabaseCluster;
53 import net.sf.hajdbc.MockDatabase;
54 import net.sf.hajdbc.Operation;
55
56 import org.easymock.EasyMock;
57 import org.easymock.IMocksControl;
58 import org.testng.annotations.AfterMethod;
59 import org.testng.annotations.BeforeClass;
60 import org.testng.annotations.Test;
61
62 /***
63  * @author Paul Ferraro
64  * @since 1.0
65  */

66 @Test
67 public class TestResultSet
68 {
69     private IMocksControl control = EasyMock.createStrictControl();
70     
71     private DatabaseCluster databaseCluster = this.control.createMock(DatabaseCluster.class);
72     
73     protected java.sql.Connection JavaDoc sqlConnection = this.control.createMock(java.sql.Connection JavaDoc.class);
74     
75     protected java.sql.Statement JavaDoc sqlStatement = this.control.createMock(java.sql.Statement JavaDoc.class);
76     
77     protected java.sql.ResultSet JavaDoc sqlResultSet = this.control.createMock(java.sql.ResultSet JavaDoc.class);
78     
79     private Database database = new MockDatabase();
80     
81     private Balancer balancer = this.control.createMock(Balancer.class);
82     
83     private FileSupport fileSupport = this.control.createMock(FileSupport.class);
84     
85     private Lock JavaDoc lock = this.control.createMock(Lock JavaDoc.class);
86     
87     private Statement statement;
88     private ResultSet resultSet;
89     private List JavaDoc<Database> databaseList = Collections.singletonList(this.database);
90     private ExecutorService JavaDoc executor = Executors.newSingleThreadExecutor();
91     
92     @BeforeClass
93     protected void setUp() throws Exception JavaDoc
94     {
95         Map JavaDoc map = Collections.singletonMap(this.database, new Object JavaDoc());
96         
97         EasyMock.expect(this.databaseCluster.getConnectionFactoryMap()).andReturn(map);
98         
99         EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
100         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
101         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
102
103         EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
104         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
105         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
106         
107         EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
108         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
109         this.lock.lock();
110         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
111         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
112         this.lock.unlock();
113                 
114         this.control.replay();
115         
116         ConnectionFactory<Object JavaDoc> connectionFactory = new ConnectionFactory<Object JavaDoc>(this.databaseCluster, Object JavaDoc.class);
117         
118         Operation<Object JavaDoc, java.sql.Connection JavaDoc> operation = new Operation<Object JavaDoc, java.sql.Connection JavaDoc>()
119         {
120             public java.sql.Connection JavaDoc execute(Database database, Object JavaDoc sqlObject) throws SQLException JavaDoc
121             {
122                 return TestResultSet.this.sqlConnection;
123             }
124         };
125         
126         Connection<Object JavaDoc> connection = new Connection<Object JavaDoc>(connectionFactory, operation, this.fileSupport);
127         
128         Operation<java.sql.Connection JavaDoc, java.sql.Statement JavaDoc> connectionOperation = new Operation<java.sql.Connection JavaDoc, java.sql.Statement JavaDoc>()
129         {
130             public java.sql.Statement JavaDoc execute(Database database, java.sql.Connection JavaDoc connection) throws SQLException JavaDoc
131             {
132                 return TestResultSet.this.sqlStatement;
133             }
134         };
135         
136         this.statement = new Statement(connection, connectionOperation);
137         
138         Operation<java.sql.Statement JavaDoc, java.sql.ResultSet JavaDoc> statementOperation = new Operation<java.sql.Statement JavaDoc, java.sql.ResultSet JavaDoc>()
139         {
140             public java.sql.ResultSet JavaDoc execute(Database database, java.sql.Statement JavaDoc statement) throws SQLException JavaDoc
141             {
142                 return TestResultSet.this.sqlResultSet;
143             }
144         };
145         
146         this.resultSet = new ResultSet(this.statement, statementOperation);
147         
148         this.control.verify();
149         this.control.reset();
150     }
151     
152     @AfterMethod
153     public void reset()
154     {
155         this.control.reset();
156     }
157     
158     /**
159      * Test method for {@link SQLObject#getObject(Database)}
160      */

161     public void testGetObject()
162     {
163         this.control.replay();
164         
165         Object JavaDoc resultSet = this.resultSet.getObject(this.database);
166         
167         this.control.verify();
168         
169         assert resultSet == this.sqlResultSet;
170     }
171
172     /**
173      * Test method for {@link SQLObject#getDatabaseCluster()}
174      */

175     public void testGetDatabaseCluster()
176     {
177         this.control.replay();
178         
179         DatabaseCluster databaseCluster = this.resultSet.getDatabaseCluster();
180         
181         this.control.verify();
182         
183         assert databaseCluster == this.databaseCluster;
184     }
185
186     /**
187      * Test method for {@link SQLObject#handleExceptions(Map)}
188      */

189     public void testHandleException()
190     {
191         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
192         EasyMock.expect(this.balancer.first()).andReturn(this.database);
193         
194         try
195         {
196             EasyMock.expect(this.sqlConnection.getAutoCommit()).andReturn(true);
197             
198             EasyMock.expect(this.databaseCluster.deactivate(this.database)).andReturn(false);
199             
200             this.control.replay();
201             
202             this.resultSet.handleExceptions(Collections.singletonMap(this.database, new SQLException JavaDoc()));
203             
204             this.control.verify();
205         }
206         catch (SQLException JavaDoc e)
207         {
208             assert false : e;
209         }
210     }
211
212     /**
213      * Test method for {@link SQLObject#handleExceptions(Map)}
214      */

215     public void testAutoCommitOffHandleException()
216     {
217         SQLException JavaDoc exception = new SQLException JavaDoc();
218         
219         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
220         EasyMock.expect(this.balancer.first()).andReturn(this.database);
221         
222         try
223         {
224             EasyMock.expect(this.sqlConnection.getAutoCommit()).andReturn(false);
225             
226             this.databaseCluster.handleFailure(this.database, exception);
227             
228             this.control.replay();
229             
230             this.resultSet.handleExceptions(Collections.singletonMap(this.database, exception));
231             
232             this.control.verify();
233         }
234         catch (SQLException JavaDoc e)
235         {
236             assert false : e;
237         }
238     }
239     
240     /**
241      * Test method for {@link ResultSet#absolute(int)}
242      */

243     public void testAbsolute()
244     {
245         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
246         
247         this.lock.lock();
248         
249         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
250         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
251         
252         try
253         {
254             EasyMock.expect(this.sqlResultSet.absolute(10)).andReturn(true);
255             
256             this.lock.unlock();
257             
258             this.control.replay();
259             
260             boolean valid = this.resultSet.absolute(10);
261             
262             this.control.verify();
263             
264             assert valid;
265         }
266         catch (SQLException JavaDoc e)
267         {
268             assert false : e;
269         }
270     }
271
272     /**
273      * Test method for {@link ResultSet#afterLast()}
274      */

275     public void testAfterLast()
276     {
277         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
278         
279         this.lock.lock();
280         
281         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
282         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
283         
284         try
285         {
286             this.sqlResultSet.afterLast();
287             
288             this.lock.unlock();
289             
290             this.control.replay();
291             
292             this.resultSet.afterLast();
293             
294             this.control.verify();
295         }
296         catch (SQLException JavaDoc e)
297         {
298             assert false : e;
299         }
300     }
301
302     /**
303      * Test method for {@link ResultSet#beforeFirst()}
304      */

305     public void testBeforeFirst()
306     {
307         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
308         
309         this.lock.lock();
310         
311         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
312         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
313         
314         try
315         {
316             this.sqlResultSet.beforeFirst();
317             
318             this.lock.unlock();
319             
320             this.control.replay();
321             
322             this.resultSet.beforeFirst();
323             
324             this.control.verify();
325         }
326         catch (SQLException JavaDoc e)
327         {
328             assert false : e;
329         }
330     }
331
332     /**
333      * Test method for {@link ResultSet#cancelRowUpdates()}
334      */

335     public void testCancelRowUpdates()
336     {
337         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
338         
339         this.lock.lock();
340         
341         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
342         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
343         
344         try
345         {
346             this.sqlResultSet.cancelRowUpdates();
347             
348             this.lock.unlock();
349             
350             this.control.replay();
351             
352             this.resultSet.cancelRowUpdates();
353             
354             this.control.verify();
355         }
356         catch (SQLException JavaDoc e)
357         {
358             assert false : e;
359         }
360     }
361
362     /**
363      * Test method for {@link ResultSet#clearWarnings()}
364      */

365     public void testClearWarnings()
366     {
367         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
368         
369         this.lock.lock();
370         
371         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
372         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
373         
374         try
375         {
376             this.sqlResultSet.clearWarnings();
377             
378             this.lock.unlock();
379             
380             this.control.replay();
381             
382             this.resultSet.clearWarnings();
383             
384             this.control.verify();
385         }
386         catch (SQLException JavaDoc e)
387         {
388             assert false : e;
389         }
390     }
391
392     /**
393      * Test method for {@link ResultSet#close()}
394      */

395     public void testClose()
396     {
397         EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
398         
399         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
400         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
401         
402         try
403         {
404             this.sqlResultSet.close();
405             
406             this.control.replay();
407             
408             this.resultSet.close();
409             
410             this.control.verify();
411         }
412         catch (SQLException JavaDoc e)
413         {
414             assert false : e;
415         }
416     }
417
418     /**
419      * Test method for {@link ResultSet#deleteRow()}
420      */

421     public void testDeleteRow()
422     {
423         EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
424         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
425         
426         this.lock.lock();
427         
428         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
429         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
430         
431         try
432         {
433             this.sqlResultSet.deleteRow();
434             
435             this.lock.unlock();
436             
437             this.control.replay();
438             
439             this.resultSet.deleteRow();
440             
441             this.control.verify();
442         }
443         catch (SQLException JavaDoc e)
444         {
445             assert false : e;
446         }
447     }
448
449     /**
450      * Test method for {@link ResultSet#findColumn(String)}
451      */

452     public void testFindColumn()
453     {
454         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
455         EasyMock.expect(this.balancer.first()).andReturn(this.database);
456         
457         try
458         {
459             EasyMock.expect(this.sqlResultSet.findColumn("test")).andReturn(1);
460             
461             this.control.replay();
462             
463             int column = this.resultSet.findColumn("test");
464             
465             this.control.verify();
466             
467             assert column == 1 : column;
468         }
469         catch (SQLException JavaDoc e)
470         {
471             assert false : e;
472         }
473     }
474
475     /**
476      * Test method for {@link ResultSet#first()}
477      */

478     public void testFirst()
479     {
480         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
481         EasyMock.expect(this.balancer.first()).andReturn(this.database);
482         
483         try
484         {
485             EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY);
486             
487             EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
488             
489             this.lock.lock();
490             
491             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
492             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
493             
494             EasyMock.expect(this.sqlResultSet.first()).andReturn(true);
495             
496             this.lock.unlock();
497             
498             this.control.replay();
499             
500             boolean valid = this.resultSet.first();
501             
502             this.control.verify();
503             
504             assert valid;
505         }
506         catch (SQLException JavaDoc e)
507         {
508             assert false : e;
509         }
510     }
511
512     /**
513      * Test method for {@link ResultSet#getArray(int)}
514      */

515     public void testGetArrayInt()
516     {
517         Array JavaDoc array = EasyMock.createMock(Array JavaDoc.class);
518         
519         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
520         EasyMock.expect(this.balancer.first()).andReturn(this.database);
521         
522         try
523         {
524             EasyMock.expect(this.sqlResultSet.getArray(1)).andReturn(array);
525             
526             this.control.replay();
527             
528             Array JavaDoc value = this.resultSet.getArray(1);
529             
530             this.control.verify();
531             
532             assert value == array;
533         }
534         catch (SQLException JavaDoc e)
535         {
536             assert false : e;
537         }
538     }
539
540     /**
541      * Test method for {@link ResultSet#getArray(String)}
542      */

543     public void testGetArrayString()
544     {
545         Array JavaDoc array = EasyMock.createMock(Array JavaDoc.class);
546         
547         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
548         EasyMock.expect(this.balancer.first()).andReturn(this.database);
549         
550         try
551         {
552             EasyMock.expect(this.sqlResultSet.getArray("column")).andReturn(array);
553             
554             this.control.replay();
555             
556             Array JavaDoc value = this.resultSet.getArray("column");
557             
558             this.control.verify();
559             
560             assert value == array;
561         }
562         catch (SQLException JavaDoc e)
563         {
564             assert false : e;
565         }
566     }
567
568     /**
569      * Test method for {@link ResultSet#getAsciiStream(int)}
570      */

571     public void testGetAsciiStreamInt()
572     {
573         InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[0]);
574         
575         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
576         EasyMock.expect(this.balancer.first()).andReturn(this.database);
577         
578         try
579         {
580             EasyMock.expect(this.sqlResultSet.getAsciiStream(1)).andReturn(inputStream);
581             
582             this.control.replay();
583             
584             InputStream JavaDoc value = this.resultSet.getAsciiStream(1);
585             
586             this.control.verify();
587             
588             assert value == inputStream;
589         }
590         catch (SQLException JavaDoc e)
591         {
592             assert false : e;
593         }
594     }
595
596     /**
597      * Test method for {@link ResultSet#getAsciiStream(String)}
598      */

599     public void testGetAsciiStreamString()
600     {
601         InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[0]);
602         
603         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
604         EasyMock.expect(this.balancer.first()).andReturn(this.database);
605         
606         try
607         {
608             EasyMock.expect(this.sqlResultSet.getAsciiStream("column")).andReturn(inputStream);
609             
610             this.control.replay();
611             
612             InputStream JavaDoc value = this.resultSet.getAsciiStream("column");
613             
614             this.control.verify();
615             
616             assert value == inputStream;
617         }
618         catch (SQLException JavaDoc e)
619         {
620             assert false : e;
621         }
622     }
623
624     /**
625      * Test method for {@link ResultSet#getBigDecimal(int)}
626      */

627     public void testGetBigDecimalInt()
628     {
629         BigDecimal JavaDoc decimal = new BigDecimal JavaDoc(1.0);
630         
631         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
632         EasyMock.expect(this.balancer.first()).andReturn(this.database);
633         
634         try
635         {
636             EasyMock.expect(this.sqlResultSet.getBigDecimal(1)).andReturn(decimal);
637             
638             this.control.replay();
639             
640             BigDecimal JavaDoc value = this.resultSet.getBigDecimal(1);
641             
642             this.control.verify();
643             
644             assert value == decimal;
645         }
646         catch (SQLException JavaDoc e)
647         {
648             assert false : e;
649         }
650     }
651
652     /***
653      * Test method for {@link ResultSet#getBigDecimal(int, int)}
654      * @deprecated
655      */

656     public void testGetBigDecimalIntInt()
657     {
658         BigDecimal JavaDoc decimal = new BigDecimal JavaDoc(1.0);
659         
660         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
661         EasyMock.expect(this.balancer.first()).andReturn(this.database);
662         
663         try
664         {
665             EasyMock.expect(this.sqlResultSet.getBigDecimal(1, 0)).andReturn(decimal);
666             
667             this.control.replay();
668             
669             BigDecimal JavaDoc value = this.resultSet.getBigDecimal(1, 0);
670             
671             this.control.verify();
672             
673             assert value == decimal;
674         }
675         catch (SQLException JavaDoc e)
676         {
677             assert false : e;
678         }
679     }
680
681     /**
682      * Test method for {@link ResultSet#getBigDecimal(String)}
683      */

684     public void testGetBigDecimalString()
685     {
686         BigDecimal JavaDoc decimal = new BigDecimal JavaDoc(1.0);
687         
688         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
689         EasyMock.expect(this.balancer.first()).andReturn(this.database);
690         
691         try
692         {
693             EasyMock.expect(this.sqlResultSet.getBigDecimal("column")).andReturn(decimal);
694             
695             this.control.replay();
696             
697             BigDecimal JavaDoc value = this.resultSet.getBigDecimal("column");
698             
699             this.control.verify();
700             
701             assert value == decimal;
702         }
703         catch (SQLException JavaDoc e)
704         {
705             assert false : e;
706         }
707     }
708
709     /***
710      * Test method for {@link ResultSet#getBigDecimal(String, int)}
711      * @deprecated
712      */

713     public void testGetBigDecimalStringInt()
714     {
715         BigDecimal JavaDoc decimal = new BigDecimal JavaDoc(1.0);
716         
717         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
718         EasyMock.expect(this.balancer.first()).andReturn(this.database);
719         
720         try
721         {
722             EasyMock.expect(this.sqlResultSet.getBigDecimal("column", 0)).andReturn(decimal);
723             
724             this.control.replay();
725             
726             BigDecimal JavaDoc value = this.resultSet.getBigDecimal("column", 0);
727             
728             this.control.verify();
729             
730             assert value == decimal;
731         }
732         catch (SQLException JavaDoc e)
733         {
734             assert false : e;
735         }
736     }
737
738     /**
739      * Test method for {@link ResultSet#getBinaryStream(int)}
740      */

741     public void testGetBinaryStreamInt()
742     {
743         InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[0]);
744         
745         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
746         EasyMock.expect(this.balancer.first()).andReturn(this.database);
747         
748         try
749         {
750             EasyMock.expect(this.sqlResultSet.getBinaryStream(1)).andReturn(inputStream);
751             
752             this.control.replay();
753             
754             InputStream JavaDoc value = this.resultSet.getBinaryStream(1);
755             
756             this.control.verify();
757             
758             assert value == inputStream;
759         }
760         catch (SQLException JavaDoc e)
761         {
762             assert false : e;
763         }
764     }
765
766     /**
767      * Test method for {@link ResultSet#getBinaryStream(String)}
768      */

769     public void testGetBinaryStreamString()
770     {
771         InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[0]);
772         
773         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
774         EasyMock.expect(this.balancer.first()).andReturn(this.database);
775         
776         try
777         {
778             EasyMock.expect(this.sqlResultSet.getBinaryStream("column")).andReturn(inputStream);
779             
780             this.control.replay();
781             
782             InputStream JavaDoc value = this.resultSet.getBinaryStream("column");
783             
784             this.control.verify();
785             
786             assert value == inputStream;
787         }
788         catch (SQLException JavaDoc e)
789         {
790             assert false : e;
791         }
792     }
793
794     /**
795      * Test method for {@link ResultSet#getBlob(int)}
796      */

797     public void testGetBlobInt()
798     {
799         Blob JavaDoc blob = EasyMock.createMock(Blob JavaDoc.class);
800         
801         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
802         EasyMock.expect(this.balancer.first()).andReturn(this.database);
803         
804         try
805         {
806             EasyMock.expect(this.sqlResultSet.getBlob(1)).andReturn(blob);
807             
808             this.control.replay();
809             
810             Blob JavaDoc value = this.resultSet.getBlob(1);
811             
812             this.control.verify();
813             
814             assert value == blob;
815         }
816         catch (SQLException JavaDoc e)
817         {
818             assert false : e;
819         }
820     }
821
822     /**
823      * Test method for {@link ResultSet#getBlob(String)}
824      */

825     public void testGetBlobString()
826     {
827         Blob JavaDoc blob = EasyMock.createMock(Blob JavaDoc.class);
828         
829         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
830         EasyMock.expect(this.balancer.first()).andReturn(this.database);
831         
832         try
833         {
834             EasyMock.expect(this.sqlResultSet.getBlob("column")).andReturn(blob);
835             
836             this.control.replay();
837             
838             Blob JavaDoc value = this.resultSet.getBlob("column");
839             
840             this.control.verify();
841             
842             assert value == blob;
843         }
844         catch (SQLException JavaDoc e)
845         {
846             assert false : e;
847         }
848     }
849
850     /**
851      * Test method for {@link ResultSet#getBoolean(int)}
852      */

853     public void testGetBooleanInt()
854     {
855         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
856         EasyMock.expect(this.balancer.first()).andReturn(this.database);
857         
858         try
859         {
860             EasyMock.expect(this.sqlResultSet.getBoolean(1)).andReturn(true);
861             
862             this.control.replay();
863             
864             boolean value = this.resultSet.getBoolean(1);
865             
866             this.control.verify();
867             
868             assert value;
869         }
870         catch (SQLException JavaDoc e)
871         {
872             assert false : e;
873         }
874     }
875
876     /**
877      * Test method for {@link ResultSet#getBoolean(String)}
878      */

879     public void testGetBooleanString()
880     {
881         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
882         EasyMock.expect(this.balancer.first()).andReturn(this.database);
883         
884         try
885         {
886             EasyMock.expect(this.sqlResultSet.getBoolean("column")).andReturn(true);
887             
888             this.control.replay();
889             
890             boolean value = this.resultSet.getBoolean("column");
891             
892             this.control.verify();
893             
894             assert value;
895         }
896         catch (SQLException JavaDoc e)
897         {
898             assert false : e;
899         }
900     }
901
902     /**
903      * Test method for {@link ResultSet#getByte(int)}
904      */

905     public void testGetByteInt()
906     {
907         byte b = 1;
908         
909         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
910         EasyMock.expect(this.balancer.first()).andReturn(this.database);
911         
912         try
913         {
914             EasyMock.expect(this.sqlResultSet.getByte(1)).andReturn(b);
915             
916             this.control.replay();
917             
918             byte value = this.resultSet.getByte(1);
919             
920             this.control.verify();
921             
922             assert value == b;
923         }
924         catch (SQLException JavaDoc e)
925         {
926             assert false : e;
927         }
928     }
929
930     /**
931      * Test method for {@link ResultSet#getByte(String)}
932      */

933     public void testGetByteString()
934     {
935         byte b = 1;
936         
937         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
938         EasyMock.expect(this.balancer.first()).andReturn(this.database);
939         
940         try
941         {
942             EasyMock.expect(this.sqlResultSet.getByte("column")).andReturn(b);
943             
944             this.control.replay();
945             
946             byte value = this.resultSet.getByte("column");
947             
948             this.control.verify();
949             
950             assert value == b;
951         }
952         catch (SQLException JavaDoc e)
953         {
954             assert false : e;
955         }
956     }
957
958     /**
959      * Test method for {@link ResultSet#getBytes(int)}
960      */

961     public void testGetBytesInt()
962     {
963         byte[] bytes = new byte[] { 1 };
964         
965         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
966         EasyMock.expect(this.balancer.first()).andReturn(this.database);
967         
968         try
969         {
970             EasyMock.expect(this.sqlResultSet.getBytes(1)).andReturn(bytes);
971             
972             this.control.replay();
973             
974             byte[] value = this.resultSet.getBytes(1);
975             
976             this.control.verify();
977             
978             assert value == bytes;
979         }
980         catch (SQLException JavaDoc e)
981         {
982             assert false : e;
983         }
984     }
985
986     /**
987      * Test method for {@link ResultSet#getBytes(String)}
988      */

989     public void testGetBytesString()
990     {
991         byte[] bytes = new byte[] { 1 };
992         
993         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
994         EasyMock.expect(this.balancer.first()).andReturn(this.database);
995         
996         try
997         {
998             EasyMock.expect(this.sqlResultSet.getBytes("column")).andReturn(bytes);
999             
1000            this.control.replay();
1001            
1002            byte[] value = this.resultSet.getBytes("column");
1003            
1004            this.control.verify();
1005            
1006            assert value == bytes;
1007        }
1008        catch (SQLException JavaDoc e)
1009        {
1010            assert false : e;
1011        }
1012    }
1013
1014    /**
1015     * Test method for {@link ResultSet#getCharacterStream(int)}
1016     */

1017    public void testGetCharacterStreamInt()
1018    {
1019        Reader JavaDoc reader = new StringReader JavaDoc("");
1020        
1021        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1022        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1023        
1024        try
1025        {
1026            EasyMock.expect(this.sqlResultSet.getCharacterStream(1)).andReturn(reader);
1027            
1028            this.control.replay();
1029            
1030            Reader JavaDoc value = this.resultSet.getCharacterStream(1);
1031            
1032            this.control.verify();
1033            
1034            assert value == reader;
1035        }
1036        catch (SQLException JavaDoc e)
1037        {
1038            assert false : e;
1039        }
1040    }
1041
1042    /**
1043     * Test method for {@link ResultSet#getCharacterStream(String)}
1044     */

1045    public void testGetCharacterStreamString()
1046    {
1047        Reader JavaDoc reader = new StringReader JavaDoc("");
1048        
1049        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1050        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1051        
1052        try
1053        {
1054            EasyMock.expect(this.sqlResultSet.getCharacterStream("column")).andReturn(reader);
1055            
1056            this.control.replay();
1057            
1058            Reader JavaDoc value = this.resultSet.getCharacterStream("column");
1059            
1060            this.control.verify();
1061            
1062            assert value == reader;
1063        }
1064        catch (SQLException JavaDoc e)
1065        {
1066            assert false : e;
1067        }
1068    }
1069
1070    /**
1071     * Test method for {@link ResultSet#getClob(int)}
1072     */

1073    public void testGetClobInt()
1074    {
1075        Clob JavaDoc clob = EasyMock.createMock(Clob JavaDoc.class);
1076        
1077        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1078        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1079        
1080        try
1081        {
1082            EasyMock.expect(this.sqlResultSet.getClob(1)).andReturn(clob);
1083            
1084            this.control.replay();
1085            
1086            Clob JavaDoc value = this.resultSet.getClob(1);
1087            
1088            this.control.verify();
1089            
1090            assert value == clob;
1091        }
1092        catch (SQLException JavaDoc e)
1093        {
1094            assert false : e;
1095        }
1096    }
1097
1098    /**
1099     * Test method for {@link ResultSet#getClob(String)}
1100     */

1101    public void testGetClobString()
1102    {
1103        Clob JavaDoc clob = EasyMock.createMock(Clob JavaDoc.class);
1104        
1105        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1106        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1107        
1108        try
1109        {
1110            EasyMock.expect(this.sqlResultSet.getClob("column")).andReturn(clob);
1111            
1112            this.control.replay();
1113            
1114            Clob JavaDoc value = this.resultSet.getClob("column");
1115            
1116            this.control.verify();
1117            
1118            assert value == clob;
1119        }
1120        catch (SQLException JavaDoc e)
1121        {
1122            assert false : e;
1123        }
1124    }
1125
1126    /**
1127     * Test method for {@link ResultSet#getConcurrency()}
1128     */

1129    public void testGetConcurrency()
1130    {
1131        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1132        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1133        
1134        try
1135        {
1136            EasyMock.expect(this.sqlResultSet.getConcurrency()).andReturn(ResultSet.CONCUR_UPDATABLE);
1137            
1138            this.control.replay();
1139            
1140            int concurrency = this.resultSet.getConcurrency();
1141            
1142            this.control.verify();
1143            
1144            assert concurrency == ResultSet.CONCUR_UPDATABLE : concurrency;
1145        }
1146        catch (SQLException JavaDoc e)
1147        {
1148            assert false : e;
1149        }
1150    }
1151
1152    /**
1153     * Test method for {@link ResultSet#getCursorName()}
1154     */

1155    public void testGetCursorName()
1156    {
1157        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1158        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1159        
1160        try
1161        {
1162            EasyMock.expect(this.sqlResultSet.getCursorName()).andReturn("test");
1163            
1164            this.control.replay();
1165            
1166            String JavaDoc cursor = this.resultSet.getCursorName();
1167            
1168            this.control.verify();
1169            
1170            assert cursor == "test";
1171        }
1172        catch (SQLException JavaDoc e)
1173        {
1174            assert false : e;
1175        }
1176    }
1177
1178    /**
1179     * Test method for {@link ResultSet#getDate(int)}
1180     */

1181    public void testGetDateInt()
1182    {
1183        Date JavaDoc date = new Date JavaDoc(System.currentTimeMillis());
1184        
1185        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1186        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1187        
1188        try
1189        {
1190            EasyMock.expect(this.sqlResultSet.getDate(1)).andReturn(date);
1191            
1192            this.control.replay();
1193            
1194            Date JavaDoc value = this.resultSet.getDate(1);
1195            
1196            this.control.verify();
1197            
1198            assert value == date;
1199        }
1200        catch (SQLException JavaDoc e)
1201        {
1202            assert false : e;
1203        }
1204    }
1205
1206    /**
1207     * Test method for {@link ResultSet#getDate(int, Calendar)}
1208     */

1209    public void testGetDateIntCalendar()
1210    {
1211        Date JavaDoc date = new Date JavaDoc(System.currentTimeMillis());
1212        Calendar JavaDoc calendar = Calendar.getInstance();
1213        
1214        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1215        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1216        
1217        try
1218        {
1219            EasyMock.expect(this.sqlResultSet.getDate(1, calendar)).andReturn(date);
1220            
1221            this.control.replay();
1222            
1223            Date JavaDoc value = this.resultSet.getDate(1, calendar);
1224            
1225            this.control.verify();
1226            
1227            assert value == date;
1228        }
1229        catch (SQLException JavaDoc e)
1230        {
1231            assert false : e;
1232        }
1233    }
1234
1235    /**
1236     * Test method for {@link ResultSet#getDate(String)}
1237     */

1238    public void testGetDateString()
1239    {
1240        Date JavaDoc date = new Date JavaDoc(System.currentTimeMillis());
1241        
1242        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1243        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1244        
1245        try
1246        {
1247            EasyMock.expect(this.sqlResultSet.getDate("column")).andReturn(date);
1248            
1249            this.control.replay();
1250            
1251            Date JavaDoc value = this.resultSet.getDate("column");
1252            
1253            this.control.verify();
1254            
1255            assert value == date;
1256        }
1257        catch (SQLException JavaDoc e)
1258        {
1259            assert false : e;
1260        }
1261    }
1262
1263    /**
1264     * Test method for {@link ResultSet#getDate(String, Calendar)}
1265     */

1266    public void testGetDateStringCalendar()
1267    {
1268        Date JavaDoc date = new Date JavaDoc(System.currentTimeMillis());
1269        Calendar JavaDoc calendar = Calendar.getInstance();
1270        
1271        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1272        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1273        
1274        try
1275        {
1276            EasyMock.expect(this.sqlResultSet.getDate("column", calendar)).andReturn(date);
1277            
1278            this.control.replay();
1279            
1280            Date JavaDoc value = this.resultSet.getDate("column", calendar);
1281            
1282            this.control.verify();
1283            
1284            assert value == date;
1285        }
1286        catch (SQLException JavaDoc e)
1287        {
1288            assert false : e;
1289        }
1290    }
1291
1292    /**
1293     * Test method for {@link ResultSet#getDouble(int)}
1294     */

1295    public void testGetDoubleInt()
1296    {
1297        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1298        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1299        
1300        try
1301        {
1302            EasyMock.expect(this.sqlResultSet.getDouble(1)).andReturn(1.0);
1303            
1304            this.control.replay();
1305            
1306            double value = this.resultSet.getDouble(1);
1307            
1308            this.control.verify();
1309            
1310            assert value == 1.0;
1311        }
1312        catch (SQLException JavaDoc e)
1313        {
1314            assert false : e;
1315        }
1316    }
1317
1318    /**
1319     * Test method for {@link ResultSet#getDouble(String)}
1320     */

1321    public void testGetDoubleString()
1322    {
1323        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1324        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1325        
1326        try
1327        {
1328            EasyMock.expect(this.sqlResultSet.getDouble("column")).andReturn(1.0);
1329            
1330            this.control.replay();
1331            
1332            double value = this.resultSet.getDouble("column");
1333            
1334            this.control.verify();
1335            
1336            assert value == 1.0;
1337        }
1338        catch (SQLException JavaDoc e)
1339        {
1340            assert false : e;
1341        }
1342    }
1343
1344    /**
1345     * Test method for {@link ResultSet#getFetchDirection()}
1346     */

1347    public void testGetFetchDirection()
1348    {
1349        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1350        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1351        
1352        try
1353        {
1354            EasyMock.expect(this.sqlResultSet.getFetchDirection()).andReturn(ResultSet.FETCH_REVERSE);
1355            
1356            this.control.replay();
1357            
1358            int direction = this.resultSet.getFetchDirection();
1359            
1360            this.control.verify();
1361            
1362            assert direction == ResultSet.FETCH_REVERSE : direction;
1363        }
1364        catch (SQLException JavaDoc e)
1365        {
1366            assert false : e;
1367        }
1368    }
1369
1370    /**
1371     * Test method for {@link ResultSet#getFetchSize()}
1372     */

1373    public void testGetFetchSize()
1374    {
1375        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1376        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1377        
1378        try
1379        {
1380            EasyMock.expect(this.sqlResultSet.getFetchSize()).andReturn(100);
1381            
1382            this.control.replay();
1383            
1384            int size = this.resultSet.getFetchSize();
1385            
1386            this.control.verify();
1387            
1388            assert size == 100 : size;
1389        }
1390        catch (SQLException JavaDoc e)
1391        {
1392            assert false : e;
1393        }
1394    }
1395
1396    /**
1397     * Test method for {@link ResultSet#getFloat(int)}
1398     */

1399    public void testGetFloatInt()
1400    {
1401        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1402        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1403        
1404        try
1405        {
1406            EasyMock.expect(this.sqlResultSet.getFloat(1)).andReturn(1.0f);
1407            
1408            this.control.replay();
1409            
1410            float value = this.resultSet.getFloat(1);
1411            
1412            this.control.verify();
1413            
1414            assert value == 1.0f;
1415        }
1416        catch (SQLException JavaDoc e)
1417        {
1418            assert false : e;
1419        }
1420    }
1421
1422    /**
1423     * Test method for {@link ResultSet#getFloat(String)}
1424     */

1425    public void testGetFloatString()
1426    {
1427        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1428        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1429        
1430        try
1431        {
1432            EasyMock.expect(this.sqlResultSet.getFloat("column")).andReturn(1.0f);
1433            
1434            this.control.replay();
1435            
1436            float value = this.resultSet.getFloat("column");
1437            
1438            this.control.verify();
1439            
1440            assert value == 1.0f;
1441        }
1442        catch (SQLException JavaDoc e)
1443        {
1444            assert false : e;
1445        }
1446    }
1447
1448    /**
1449     * Test method for {@link ResultSet#getInt(int)}
1450     */

1451    public void testGetIntInt()
1452    {
1453        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1454        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1455        
1456        try
1457        {
1458            EasyMock.expect(this.sqlResultSet.getInt(1)).andReturn(1);
1459            
1460            this.control.replay();
1461            
1462            int value = this.resultSet.getInt(1);
1463            
1464            this.control.verify();
1465            
1466            assert value == 1;
1467        }
1468        catch (SQLException JavaDoc e)
1469        {
1470            assert false : e;
1471        }
1472    }
1473
1474    /**
1475     * Test method for {@link ResultSet#getInt(String)}
1476     */

1477    public void testGetIntString()
1478    {
1479        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1480        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1481        
1482        try
1483        {
1484            EasyMock.expect(this.sqlResultSet.getInt("column")).andReturn(1);
1485            
1486            this.control.replay();
1487            
1488            int value = this.resultSet.getInt("column");
1489            
1490            this.control.verify();
1491            
1492            assert value == 1;
1493        }
1494        catch (SQLException JavaDoc e)
1495        {
1496            assert false : e;
1497        }
1498    }
1499
1500    /**
1501     * Test method for {@link ResultSet#getLong(int)}
1502     */

1503    public void testGetLongInt()
1504    {
1505        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1506        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1507        
1508        try
1509        {
1510            EasyMock.expect(this.sqlResultSet.getLong(1)).andReturn(100L);
1511            
1512            this.control.replay();
1513            
1514            long value = this.resultSet.getLong(1);
1515            
1516            this.control.verify();
1517            
1518            assert value == 100L;
1519        }
1520        catch (SQLException JavaDoc e)
1521        {
1522            assert false : e;
1523        }
1524    }
1525
1526    /**
1527     * Test method for {@link ResultSet#getLong(String)}
1528     */

1529    public void testGetLongString()
1530    {
1531        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1532        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1533        
1534        try
1535        {
1536            EasyMock.expect(this.sqlResultSet.getLong("column")).andReturn(100L);
1537            
1538            this.control.replay();
1539            
1540            long value = this.resultSet.getLong("column");
1541            
1542            this.control.verify();
1543            
1544            assert value == 100L;
1545        }
1546        catch (SQLException JavaDoc e)
1547        {
1548            assert false : e;
1549        }
1550    }
1551
1552    /**
1553     * Test method for {@link ResultSet#getMetaData()}
1554     */

1555    public void testGetMetaData()
1556    {
1557        ResultSetMetaData JavaDoc resultSetMetaData = EasyMock.createMock(ResultSetMetaData JavaDoc.class);
1558        
1559        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1560        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1561        
1562        try
1563        {
1564            EasyMock.expect(this.sqlResultSet.getMetaData()).andReturn(resultSetMetaData);
1565            
1566            this.control.replay();
1567            
1568            ResultSetMetaData JavaDoc metaData = this.resultSet.getMetaData();
1569            
1570            this.control.verify();
1571            
1572            assert metaData == resultSetMetaData;
1573        }
1574        catch (SQLException JavaDoc e)
1575        {
1576            assert false : e;
1577        }
1578    }
1579
1580    /**
1581     * Test method for {@link ResultSet#getObject(int)}
1582     */

1583    public void testGetObjectInt()
1584    {
1585        Object JavaDoc object = new Object JavaDoc();
1586        
1587        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1588        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1589        
1590        try
1591        {
1592            EasyMock.expect(this.sqlResultSet.getObject(1)).andReturn(object);
1593            
1594            this.control.replay();
1595            
1596            Object JavaDoc value = this.resultSet.getObject(1);
1597            
1598            this.control.verify();
1599            
1600            assert value == object;
1601        }
1602        catch (SQLException JavaDoc e)
1603        {
1604            assert false : e;
1605        }
1606    }
1607
1608    /**
1609     * Test method for {@link ResultSet#getObject(int, Map)}
1610     */

1611    public void testGetObjectIntMap()
1612    {
1613        Object JavaDoc object = new Object JavaDoc();
1614        
1615        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1616        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1617        
1618        try
1619        {
1620            EasyMock.expect(this.sqlResultSet.getObject(1, Collections.EMPTY_MAP)).andReturn(object);
1621            
1622            this.control.replay();
1623            
1624            Object JavaDoc value = this.resultSet.getObject(1, Collections.EMPTY_MAP);
1625            
1626            this.control.verify();
1627            
1628            assert value == object;
1629        }
1630        catch (SQLException JavaDoc e)
1631        {
1632            assert false : e;
1633        }
1634    }
1635
1636    /**
1637     * Test method for {@link ResultSet#getObject(String)}
1638     */

1639    public void testGetObjectString()
1640    {
1641        Object JavaDoc object = new Object JavaDoc();
1642        
1643        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1644        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1645        
1646        try
1647        {
1648            EasyMock.expect(this.sqlResultSet.getObject("column")).andReturn(object);
1649            
1650            this.control.replay();
1651            
1652            Object JavaDoc value = this.resultSet.getObject("column");
1653            
1654            this.control.verify();
1655            
1656            assert value == object;
1657        }
1658        catch (SQLException JavaDoc e)
1659        {
1660            assert false : e;
1661        }
1662    }
1663
1664    /**
1665     * Test method for {@link ResultSet#getObject(String, Map)}
1666     */

1667    public void testGetObjectStringMap()
1668    {
1669        Object JavaDoc object = new Object JavaDoc();
1670        
1671        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1672        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1673        
1674        try
1675        {
1676            EasyMock.expect(this.sqlResultSet.getObject("column", Collections.EMPTY_MAP)).andReturn(object);
1677            
1678            this.control.replay();
1679            
1680            Object JavaDoc value = this.resultSet.getObject("column", Collections.EMPTY_MAP);
1681            
1682            this.control.verify();
1683            
1684            assert value == object;
1685        }
1686        catch (SQLException JavaDoc e)
1687        {
1688            assert false : e;
1689        }
1690    }
1691
1692    /**
1693     * Test method for {@link ResultSet#getRef(int)}
1694     */

1695    public void testGetRefInt()
1696    {
1697        Ref JavaDoc ref = EasyMock.createMock(Ref JavaDoc.class);
1698        
1699        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1700        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1701        
1702        try
1703        {
1704            EasyMock.expect(this.sqlResultSet.getRef(1)).andReturn(ref);
1705            
1706            this.control.replay();
1707            
1708            Ref JavaDoc value = this.resultSet.getRef(1);
1709            
1710            this.control.verify();
1711            
1712            assert value == ref;
1713        }
1714        catch (SQLException JavaDoc e)
1715        {
1716            assert false : e;
1717        }
1718    }
1719
1720    /**
1721     * Test method for {@link ResultSet#getRef(String)}
1722     */

1723    public void testGetRefString()
1724    {
1725        Ref JavaDoc ref = EasyMock.createMock(Ref JavaDoc.class);
1726        
1727        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1728        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1729        
1730        try
1731        {
1732            EasyMock.expect(this.sqlResultSet.getRef("column")).andReturn(ref);
1733            
1734            this.control.replay();
1735            
1736            Ref JavaDoc value = this.resultSet.getRef("column");
1737            
1738            this.control.verify();
1739            
1740            assert value == ref;
1741        }
1742        catch (SQLException JavaDoc e)
1743        {
1744            assert false : e;
1745        }
1746    }
1747
1748    /**
1749     * Test method for {@link ResultSet#getRow()}
1750     */

1751    public void testGetRow()
1752    {
1753        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1754        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1755        
1756        try
1757        {
1758            EasyMock.expect(this.sqlResultSet.getRow()).andReturn(10);
1759            
1760            this.control.replay();
1761            
1762            int row = this.resultSet.getRow();
1763            
1764            this.control.verify();
1765            
1766            assert row == 10 : row;
1767        }
1768        catch (SQLException JavaDoc e)
1769        {
1770            assert false : e;
1771        }
1772    }
1773
1774    /**
1775     * Test method for {@link ResultSet#getShort(int)}
1776     */

1777    public void testGetShortInt()
1778    {
1779        short s = Integer.valueOf(1).shortValue();
1780        
1781        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1782        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1783        
1784        try
1785        {
1786            EasyMock.expect(this.sqlResultSet.getShort(1)).andReturn(s);
1787            
1788            this.control.replay();
1789            
1790            short value = this.resultSet.getShort(1);
1791            
1792            this.control.verify();
1793            
1794            assert value == s;
1795        }
1796        catch (SQLException JavaDoc e)
1797        {
1798            assert false : e;
1799        }
1800    }
1801
1802    /**
1803     * Test method for {@link ResultSet#getShort(String)}
1804     */

1805    public void testGetShortString()
1806    {
1807        short s = Integer.valueOf(1).shortValue();
1808        
1809        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1810        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1811        
1812        try
1813        {
1814            EasyMock.expect(this.sqlResultSet.getShort("column")).andReturn(s);
1815            
1816            this.control.replay();
1817            
1818            short value = this.resultSet.getShort("column");
1819            
1820            this.control.verify();
1821            
1822            assert value == s;
1823        }
1824        catch (SQLException JavaDoc e)
1825        {
1826            assert false : e;
1827        }
1828    }
1829
1830    /**
1831     * Test method for {@link ResultSet#getStatement()}
1832     */

1833    public void testGetStatement()
1834    {
1835        java.sql.Statement JavaDoc statement = this.resultSet.getStatement();
1836        
1837        assert statement == this.statement;
1838    }
1839
1840    /**
1841     * Test method for {@link ResultSet#getString(int)}
1842     */

1843    public void testGetStringInt()
1844    {
1845        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1846        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1847        
1848        try
1849        {
1850            EasyMock.expect(this.sqlResultSet.getString(1)).andReturn("test");
1851            
1852            this.control.replay();
1853            
1854            String JavaDoc value = this.resultSet.getString(1);
1855            
1856            this.control.verify();
1857            
1858            assert value == "test";
1859        }
1860        catch (SQLException JavaDoc e)
1861        {
1862            assert false : e;
1863        }
1864    }
1865
1866    /**
1867     * Test method for {@link ResultSet#getString(String)}
1868     */

1869    public void testGetStringString()
1870    {
1871        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1872        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1873        
1874        try
1875        {
1876            EasyMock.expect(this.sqlResultSet.getString("column")).andReturn("test");
1877            
1878            this.control.replay();
1879            
1880            String JavaDoc value = this.resultSet.getString("column");
1881            
1882            this.control.verify();
1883            
1884            assert value == "test";
1885        }
1886        catch (SQLException JavaDoc e)
1887        {
1888            assert false : e;
1889        }
1890    }
1891
1892    /**
1893     * Test method for {@link ResultSet#getTime(int)}
1894     */

1895    public void testGetTimeInt()
1896    {
1897        Time JavaDoc time = new Time JavaDoc(System.currentTimeMillis());
1898        
1899        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1900        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1901        
1902        try
1903        {
1904            EasyMock.expect(this.sqlResultSet.getTime(1)).andReturn(time);
1905            
1906            this.control.replay();
1907            
1908            Time JavaDoc value = this.resultSet.getTime(1);
1909            
1910            this.control.verify();
1911            
1912            assert value == time;
1913        }
1914        catch (SQLException JavaDoc e)
1915        {
1916            assert false : e;
1917        }
1918    }
1919
1920    /**
1921     * Test method for {@link ResultSet#getTime(int, Calendar)}
1922     */

1923    public void testGetTimeIntCalendar()
1924    {
1925        Time JavaDoc time = new Time JavaDoc(System.currentTimeMillis());
1926        Calendar JavaDoc calendar = Calendar.getInstance();
1927        
1928        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1929        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1930        
1931        try
1932        {
1933            EasyMock.expect(this.sqlResultSet.getTime(1, calendar)).andReturn(time);
1934            
1935            this.control.replay();
1936            
1937            Time JavaDoc value = this.resultSet.getTime(1, calendar);
1938            
1939            this.control.verify();
1940            
1941            assert value == time;
1942        }
1943        catch (SQLException JavaDoc e)
1944        {
1945            assert false : e;
1946        }
1947    }
1948
1949    /**
1950     * Test method for {@link ResultSet#getTime(String)}
1951     */

1952    public void testGetTimeString()
1953    {
1954        Time JavaDoc time = new Time JavaDoc(System.currentTimeMillis());
1955        
1956        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1957        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1958        
1959        try
1960        {
1961            EasyMock.expect(this.sqlResultSet.getTime("column")).andReturn(time);
1962            
1963            this.control.replay();
1964            
1965            Time JavaDoc value = this.resultSet.getTime("column");
1966            
1967            this.control.verify();
1968            
1969            assert value == time;
1970        }
1971        catch (SQLException JavaDoc e)
1972        {
1973            assert false : e;
1974        }
1975    }
1976
1977    /**
1978     * Test method for {@link ResultSet#getTime(String, Calendar)}
1979     */

1980    public void testGetTimeStringCalendar()
1981    {
1982        Time JavaDoc time = new Time JavaDoc(System.currentTimeMillis());
1983        Calendar JavaDoc calendar = Calendar.getInstance();
1984        
1985        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1986        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1987        
1988        try
1989        {
1990            EasyMock.expect(this.sqlResultSet.getTime("column", calendar)).andReturn(time);
1991            
1992            this.control.replay();
1993            
1994            Time JavaDoc value = this.resultSet.getTime("column", calendar);
1995            
1996            this.control.verify();
1997            
1998            assert value == time;
1999        }
2000        catch (SQLException JavaDoc e)
2001        {
2002            assert false : e;
2003        }
2004    }
2005
2006    /**
2007     * Test method for {@link ResultSet#getTimestamp(int)}
2008     */

2009    public void testGetTimestampInt()
2010    {
2011        Timestamp JavaDoc timestamp = new Timestamp JavaDoc(System.currentTimeMillis());
2012        
2013        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2014        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2015        
2016        try
2017        {
2018            EasyMock.expect(this.sqlResultSet.getTimestamp(1)).andReturn(timestamp);
2019            
2020            this.control.replay();
2021            
2022            Timestamp JavaDoc value = this.resultSet.getTimestamp(1);
2023            
2024            this.control.verify();
2025            
2026            assert value == timestamp;
2027        }
2028        catch (SQLException JavaDoc e)
2029        {
2030            assert false : e;
2031        }
2032    }
2033
2034    /**
2035     * Test method for {@link ResultSet#getTimestamp(int, Calendar)}
2036     */

2037    public void testGetTimestampIntCalendar()
2038    {
2039        Timestamp JavaDoc timestamp = new Timestamp JavaDoc(System.currentTimeMillis());
2040        Calendar JavaDoc calendar = Calendar.getInstance();
2041        
2042        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2043        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2044        
2045        try
2046        {
2047            EasyMock.expect(this.sqlResultSet.getTimestamp(1, calendar)).andReturn(timestamp);
2048            
2049            this.control.replay();
2050            
2051            Timestamp JavaDoc value = this.resultSet.getTimestamp(1, calendar);
2052            
2053            this.control.verify();
2054            
2055            assert value == timestamp;
2056        }
2057        catch (SQLException JavaDoc e)
2058        {
2059            assert false : e;
2060        }
2061    }
2062
2063    /**
2064     * Test method for {@link ResultSet#getTimestamp(String)}
2065     */

2066    public void testGetTimestampString()
2067    {
2068        Timestamp JavaDoc timestamp = new Timestamp JavaDoc(System.currentTimeMillis());
2069        
2070        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2071        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2072        
2073        try
2074        {
2075            EasyMock.expect(this.sqlResultSet.getTimestamp("column")).andReturn(timestamp);
2076            
2077            this.control.replay();
2078            
2079            Timestamp JavaDoc value = this.resultSet.getTimestamp("column");
2080            
2081            this.control.verify();
2082            
2083            assert value == timestamp;
2084        }
2085        catch (SQLException JavaDoc e)
2086        {
2087            assert false : e;
2088        }
2089    }
2090
2091    /**
2092     * Test method for {@link ResultSet#getTimestamp(String, Calendar)}
2093     */

2094    public void testGetTimestampStringCalendar()
2095    {
2096        Timestamp JavaDoc timestamp = new Timestamp JavaDoc(System.currentTimeMillis());
2097        Calendar JavaDoc calendar = Calendar.getInstance();
2098        
2099        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2100        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2101        
2102        try
2103        {
2104            EasyMock.expect(this.sqlResultSet.getTimestamp("column", calendar)).andReturn(timestamp);
2105            
2106            this.control.replay();
2107            
2108            Timestamp JavaDoc value = this.resultSet.getTimestamp("column", calendar);
2109            
2110            this.control.verify();
2111            
2112            assert value == timestamp;
2113        }
2114        catch (SQLException JavaDoc e)
2115        {
2116            assert false : e;
2117        }
2118    }
2119
2120    /**
2121     * Test method for {@link ResultSet#getType()}
2122     */

2123    public void testGetType()
2124    {
2125        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2126        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2127        
2128        try
2129        {
2130            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_SCROLL_INSENSITIVE);
2131            
2132            this.control.replay();
2133            
2134            int type = this.resultSet.getType();
2135            
2136            this.control.verify();
2137            
2138            assert type == ResultSet.TYPE_SCROLL_INSENSITIVE : type;
2139        }
2140        catch (SQLException JavaDoc e)
2141        {
2142            assert false : e;
2143        }
2144    }
2145
2146    /***
2147     * Test method for {@link ResultSet#getUnicodeStream(int)}
2148     * @deprecated
2149     */

2150    public void testGetUnicodeStreamInt()
2151    {
2152        InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[0]);
2153        
2154        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2155        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2156        
2157        try
2158        {
2159            EasyMock.expect(this.sqlResultSet.getUnicodeStream(1)).andReturn(inputStream);
2160            
2161            this.control.replay();
2162            
2163            InputStream JavaDoc value = this.resultSet.getUnicodeStream(1);
2164            
2165            this.control.verify();
2166            
2167            assert value == inputStream;
2168        }
2169        catch (SQLException JavaDoc e)
2170        {
2171            assert false : e;
2172        }
2173    }
2174
2175    /***
2176     * Test method for {@link ResultSet#getUnicodeStream(String)}
2177     * @deprecated
2178     */

2179    public void testGetUnicodeStreamString()
2180    {
2181        InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[0]);
2182        
2183        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2184        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2185        
2186        try
2187        {
2188            EasyMock.expect(this.sqlResultSet.getUnicodeStream("column")).andReturn(inputStream);
2189            
2190            this.control.replay();
2191            
2192            InputStream JavaDoc value = this.resultSet.getUnicodeStream("column");
2193            
2194            this.control.verify();
2195            
2196            assert value == inputStream;
2197        }
2198        catch (SQLException JavaDoc e)
2199        {
2200            assert false : e;
2201        }
2202    }
2203
2204    /**
2205     * Test method for {@link ResultSet#getURL(int)}
2206     */

2207    public void testGetURLInt()
2208    {
2209        try
2210        {
2211            URL JavaDoc url = new URL JavaDoc("http://www.google.com");
2212            
2213            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2214            EasyMock.expect(this.balancer.first()).andReturn(this.database);
2215            
2216            EasyMock.expect(this.sqlResultSet.getURL(1)).andReturn(url);
2217            
2218            this.control.replay();
2219            
2220            URL JavaDoc value = this.resultSet.getURL(1);
2221            
2222            this.control.verify();
2223            
2224            assert value == url;
2225        }
2226        catch (SQLException JavaDoc e)
2227        {
2228            assert false : e;
2229        }
2230        catch (MalformedURLException JavaDoc e)
2231        {
2232            assert false : e;
2233        }
2234    }
2235
2236    /**
2237     * Test method for {@link ResultSet#getURL(String)}
2238     */

2239    public void testGetURLString()
2240    {
2241        try
2242        {
2243            URL JavaDoc url = new URL JavaDoc("http://www.google.com");
2244            
2245            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2246            EasyMock.expect(this.balancer.first()).andReturn(this.database);
2247            
2248            EasyMock.expect(this.sqlResultSet.getURL("column")).andReturn(url);
2249            
2250            this.control.replay();
2251            
2252            URL JavaDoc value = this.resultSet.getURL("column");
2253            
2254            this.control.verify();
2255            
2256            assert value == url;
2257        }
2258        catch (SQLException JavaDoc e)
2259        {
2260            assert false : e;
2261        }
2262        catch (MalformedURLException JavaDoc e)
2263        {
2264            assert false : e;
2265        }
2266    }
2267
2268    /**
2269     * Test method for {@link ResultSet#getWarnings()}
2270     */

2271    public void testGetWarnings()
2272    {
2273        SQLWarning JavaDoc warnings = new SQLWarning JavaDoc();
2274        
2275        try
2276        {
2277            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2278            EasyMock.expect(this.balancer.first()).andReturn(this.database);
2279            
2280            EasyMock.expect(this.sqlResultSet.getWarnings()).andReturn(warnings);
2281            
2282            this.control.replay();
2283            
2284            SQLWarning JavaDoc value = this.resultSet.getWarnings();
2285            
2286            this.control.verify();
2287            
2288            assert value == warnings;
2289        }
2290        catch (SQLException JavaDoc e)
2291        {
2292            assert false : e;
2293        }
2294    }
2295
2296    /**
2297     * Test method for {@link ResultSet#insertRow()}
2298     */

2299    public void testInsertRow()
2300    {
2301        EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
2302        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2303        
2304        this.lock.lock();
2305        
2306        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2307        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2308        
2309        try
2310        {
2311            this.sqlResultSet.insertRow();
2312            
2313            this.lock.unlock();
2314            
2315            this.control.replay();
2316            
2317            this.resultSet.insertRow();
2318            
2319            this.control.verify();
2320        }
2321        catch (SQLException JavaDoc e)
2322        {
2323            assert false : e;
2324        }
2325    }
2326
2327    /**
2328     * Test method for {@link ResultSet#isAfterLast()}
2329     */

2330    public void testIsAfterLast()
2331    {
2332        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2333        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2334        
2335        try
2336        {
2337            EasyMock.expect(this.sqlResultSet.isAfterLast()).andReturn(true);
2338            
2339            this.control.replay();
2340            
2341            boolean afterLast = this.resultSet.isAfterLast();
2342            
2343            this.control.verify();
2344            
2345            assert afterLast;
2346        }
2347        catch (SQLException JavaDoc e)
2348        {
2349            assert false : e;
2350        }
2351    }
2352
2353    /**
2354     * Test method for {@link ResultSet#isBeforeFirst()}
2355     */

2356    public void testIsBeforeFirst()
2357    {
2358        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2359        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2360        
2361        try
2362        {
2363            EasyMock.expect(this.sqlResultSet.isBeforeFirst()).andReturn(true);
2364            
2365            this.control.replay();
2366            
2367            boolean beforeFirst = this.resultSet.isBeforeFirst();
2368            
2369            this.control.verify();
2370            
2371            assert beforeFirst;
2372        }
2373        catch (SQLException JavaDoc e)
2374        {
2375            assert false : e;
2376        }
2377    }
2378
2379    /**
2380     * Test method for {@link ResultSet#isFirst()}
2381     */

2382    public void testIsFirst()
2383    {
2384        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2385        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2386        
2387        try
2388        {
2389            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY);
2390            
2391            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2392            EasyMock.expect(this.balancer.first()).andReturn(this.database);
2393            
2394            EasyMock.expect(this.sqlResultSet.isFirst()).andReturn(true);
2395            
2396            this.control.replay();
2397            
2398            boolean first = this.resultSet.isFirst();
2399            
2400            this.control.verify();
2401            
2402            assert first;
2403        }
2404        catch (SQLException JavaDoc e)
2405        {
2406            assert false : e;
2407        }
2408    }
2409
2410    /**
2411     * Test method for {@link ResultSet#isFirst()}
2412     */

2413    public void testScrollSensitiveIsFirst()
2414    {
2415        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2416        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2417        
2418        try
2419        {
2420            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_SCROLL_SENSITIVE);
2421            
2422            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2423            EasyMock.expect(this.balancer.next()).andReturn(this.database);
2424            
2425            this.balancer.beforeOperation(this.database);
2426            
2427            EasyMock.expect(this.sqlResultSet.isFirst()).andReturn(true);
2428            
2429            this.balancer.afterOperation(this.database);
2430            
2431            this.control.replay();
2432            
2433            boolean first = this.resultSet.isFirst();
2434            
2435            this.control.verify();
2436            
2437            assert first;
2438        }
2439        catch (SQLException JavaDoc e)
2440        {
2441            assert false : e;
2442        }
2443    }
2444
2445    /**
2446     * Test method for {@link ResultSet#isLast()}
2447     */

2448    public void testIsLast()
2449    {
2450        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2451        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2452        
2453        try
2454        {
2455            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY);
2456            
2457            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2458            EasyMock.expect(this.balancer.first()).andReturn(this.database);
2459            
2460            EasyMock.expect(this.sqlResultSet.isLast()).andReturn(true);
2461            
2462            this.control.replay();
2463            
2464            boolean last = this.resultSet.isLast();
2465            
2466            this.control.verify();
2467            
2468            assert last;
2469        }
2470        catch (SQLException JavaDoc e)
2471        {
2472            assert false : e;
2473        }
2474    }
2475
2476    /**
2477     * Test method for {@link ResultSet#isLast()}
2478     */

2479    public void testScrollSensitiveIsLast()
2480    {
2481        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2482        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2483        
2484        try
2485        {
2486            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_SCROLL_SENSITIVE);
2487            
2488            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2489            EasyMock.expect(this.balancer.next()).andReturn(this.database);
2490            
2491            this.balancer.beforeOperation(this.database);
2492            
2493            EasyMock.expect(this.sqlResultSet.isLast()).andReturn(true);
2494            
2495            this.balancer.afterOperation(this.database);
2496            
2497            this.control.replay();
2498            
2499            boolean last = this.resultSet.isLast();
2500            
2501            this.control.verify();
2502            
2503            assert last;
2504        }
2505        catch (SQLException JavaDoc e)
2506        {
2507            assert false : e;
2508        }
2509    }
2510
2511    /**
2512     * Test method for {@link ResultSet#last()}
2513     */

2514    public void testLast()
2515    {
2516        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2517        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2518        
2519        try
2520        {
2521            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY);
2522            
2523            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2524            
2525            this.lock.lock();
2526            
2527            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2528            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2529            
2530            EasyMock.expect(this.sqlResultSet.last()).andReturn(true);
2531            
2532            this.lock.unlock();
2533            
2534            this.control.replay();
2535            
2536            boolean valid = this.resultSet.last();
2537            
2538            this.control.verify();
2539            
2540            assert valid;
2541        }
2542        catch (SQLException JavaDoc e)
2543        {
2544            assert false : e;
2545        }
2546    }
2547
2548    /**
2549     * Test method for {@link ResultSet#moveToCurrentRow()}
2550     */

2551    public void testMoveToCurrentRow()
2552    {
2553        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2554        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2555        
2556        try
2557        {
2558            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY);
2559            
2560            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2561            
2562            this.lock.lock();
2563            
2564            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2565            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2566            
2567            this.sqlResultSet.moveToCurrentRow();
2568            
2569            this.lock.unlock();
2570            
2571            this.control.replay();
2572            
2573            this.resultSet.moveToCurrentRow();
2574            
2575            this.control.verify();
2576        }
2577        catch (SQLException JavaDoc e)
2578        {
2579            assert false : e;
2580        }
2581    }
2582
2583    /**
2584     * Test method for {@link ResultSet#moveToInsertRow()}
2585     */

2586    public void testMoveToInsertRow()
2587    {
2588        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2589        
2590        this.lock.lock();
2591        
2592        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2593        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2594        
2595        try
2596        {
2597            this.sqlResultSet.moveToInsertRow();
2598            
2599            this.lock.unlock();
2600            
2601            this.control.replay();
2602            
2603            this.resultSet.moveToInsertRow();
2604            
2605            this.control.verify();
2606        }
2607        catch (SQLException JavaDoc e)
2608        {
2609            assert false : e;
2610        }
2611    }
2612
2613    /**
2614     * Test method for {@link ResultSet#next()}
2615     */

2616    public void testNext()
2617    {
2618        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2619        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2620        
2621        try
2622        {
2623            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY);
2624            
2625            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2626            
2627            this.lock.lock();
2628            
2629            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2630            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2631
2632            EasyMock.expect(this.sqlResultSet.next()).andReturn(true);
2633            
2634            this.lock.unlock();
2635            
2636            this.control.replay();
2637            
2638            boolean valid = this.resultSet.next();
2639            
2640            this.control.verify();
2641            
2642            assert valid;
2643        }
2644        catch (SQLException JavaDoc e)
2645        {
2646            assert false : e;
2647        }
2648    }
2649
2650    /**
2651     * Test method for {@link ResultSet#previous()}
2652     */

2653    public void testPrevious()
2654    {
2655        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2656        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2657        
2658        try
2659        {
2660            EasyMock.expect(this.sqlResultSet.getType()).andReturn(ResultSet.TYPE_FORWARD_ONLY);
2661            
2662            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2663            
2664            this.lock.lock();
2665            
2666            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2667            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2668            
2669            EasyMock.expect(this.sqlResultSet.previous()).andReturn(true);
2670            
2671            this.lock.unlock();
2672            
2673            this.control.replay();
2674            
2675            boolean valid = this.resultSet.previous();
2676            
2677            this.control.verify();
2678            
2679            assert valid;
2680        }
2681        catch (SQLException JavaDoc e)
2682        {
2683            assert false : e;
2684        }
2685    }
2686
2687    /**
2688     * Test method for {@link ResultSet#refreshRow()}
2689     */

2690    public void testRefreshRow()
2691    {
2692        EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
2693        
2694        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2695        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2696        
2697        try
2698        {
2699            this.sqlResultSet.refreshRow();
2700            
2701            this.control.replay();
2702            
2703            this.resultSet.refreshRow();
2704            
2705            this.control.verify();
2706        }
2707        catch (SQLException JavaDoc e)
2708        {
2709            assert false : e;
2710        }
2711    }
2712
2713    /**
2714     * Test method for {@link ResultSet#relative(int)}
2715     */

2716    public void testRelative()
2717    {
2718        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2719        
2720        this.lock.lock();
2721        
2722        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2723        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2724        
2725        try
2726        {
2727            EasyMock.expect(this.sqlResultSet.relative(10)).andReturn(true);
2728            
2729            this.lock.unlock();
2730            
2731            this.control.replay();
2732            
2733            boolean valid = this.resultSet.relative(10);
2734            
2735            this.control.verify();
2736            
2737            assert valid;
2738        }
2739        catch (SQLException JavaDoc e)
2740        {
2741            assert false : e;
2742        }
2743    }
2744
2745    /**
2746     * Test method for {@link ResultSet#rowDeleted()}
2747     */

2748    public void testRowDeleted()
2749    {
2750        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2751        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2752        
2753        try
2754        {
2755            EasyMock.expect(this.sqlResultSet.rowDeleted()).andReturn(true);
2756            
2757            this.control.replay();
2758            
2759            boolean deleted = this.resultSet.rowDeleted();
2760            
2761            this.control.verify();
2762            
2763            assert deleted;
2764        }
2765        catch (SQLException JavaDoc e)
2766        {
2767            assert false : e;
2768        }
2769    }
2770
2771    /**
2772     * Test method for {@link ResultSet#rowInserted()}
2773     */

2774    public void testRowInserted()
2775    {
2776        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2777        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2778        
2779        try
2780        {
2781            EasyMock.expect(this.sqlResultSet.rowUpdated()).andReturn(true);
2782            
2783            this.control.replay();
2784            
2785            boolean updated = this.resultSet.rowUpdated();
2786            
2787            this.control.verify();
2788            
2789            assert updated;
2790        }
2791        catch (SQLException JavaDoc e)
2792        {
2793            assert false : e;
2794        }
2795    }
2796
2797    /**
2798     * Test method for {@link ResultSet#rowUpdated()}
2799     */

2800    public void testRowUpdated()
2801    {
2802        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2803        EasyMock.expect(this.balancer.first()).andReturn(this.database);
2804        
2805        try
2806        {
2807            EasyMock.expect(this.sqlResultSet.rowInserted()).andReturn(true);
2808            
2809            this.control.replay();
2810            
2811            boolean inserted = this.resultSet.rowInserted();
2812            
2813            this.control.verify();
2814            
2815            assert inserted;
2816        }
2817        catch (SQLException JavaDoc e)
2818        {
2819            assert false : e;
2820        }
2821    }
2822
2823    /**
2824     * Test method for {@link ResultSet#setFetchDirection(int)}
2825     */

2826    public void testSetFetchDirection()
2827    {
2828        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2829        
2830        this.lock.lock();
2831        
2832        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2833        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2834        
2835        try
2836        {
2837            this.sqlResultSet.setFetchDirection(ResultSet.FETCH_REVERSE);
2838            
2839            this.lock.unlock();
2840            
2841            this.control.replay();
2842            
2843            this.resultSet.setFetchDirection(ResultSet.FETCH_REVERSE);
2844            
2845            this.control.verify();
2846        }
2847        catch (SQLException JavaDoc e)
2848        {
2849            assert false : e;
2850        }
2851    }
2852
2853    /**
2854     * Test method for {@link ResultSet#setFetchSize(int)}
2855     */

2856    public void testSetFetchSize()
2857    {
2858        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2859        
2860        this.lock.lock();
2861        
2862        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2863        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2864        
2865        try
2866        {
2867            this.sqlResultSet.setFetchSize(100);
2868            
2869            this.lock.unlock();
2870            
2871            this.control.replay();
2872            
2873            this.resultSet.setFetchSize(100);
2874            
2875            this.control.verify();
2876        }
2877        catch (SQLException JavaDoc e)
2878        {
2879            assert false : e;
2880        }
2881    }
2882
2883    /**
2884     * Test method for {@link ResultSet#updateArray(int, Array)}
2885     */

2886    public void testUpdateArrayIntArray()
2887    {
2888        Array JavaDoc array = EasyMock.createMock(Array JavaDoc.class);
2889        
2890        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2891        
2892        this.lock.lock();
2893        
2894        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2895        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2896        
2897        try
2898        {
2899            this.sqlResultSet.updateArray(1, array);
2900            
2901            this.lock.unlock();
2902            
2903            this.control.replay();
2904            
2905            this.resultSet.updateArray(1, array);
2906            
2907            this.control.verify();
2908        }
2909        catch (SQLException JavaDoc e)
2910        {
2911            assert false : e;
2912        }
2913    }
2914
2915    /**
2916     * Test method for {@link ResultSet#updateArray(String, Array)}
2917     */

2918    public void testUpdateArrayStringArray()
2919    {
2920        Array JavaDoc array = EasyMock.createMock(Array JavaDoc.class);
2921        
2922        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2923        
2924        this.lock.lock();
2925        
2926        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2927        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2928        
2929        try
2930        {
2931            this.sqlResultSet.updateArray("column", array);
2932            
2933            this.lock.unlock();
2934            
2935            this.control.replay();
2936            
2937            this.resultSet.updateArray("column", array);
2938            
2939            this.control.verify();
2940        }
2941        catch (SQLException JavaDoc e)
2942        {
2943            assert false : e;
2944        }
2945    }
2946
2947    /**
2948     * Test method for {@link ResultSet#updateAsciiStream(int, InputStream, int)}
2949     */

2950    public void testUpdateAsciiStreamIntInputStreamInt()
2951    {
2952        InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[] { 1 });
2953        File JavaDoc file = new File JavaDoc("");
2954        
2955        try
2956        {
2957            EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
2958            
2959            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2960            
2961            this.lock.lock();
2962            
2963            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2964            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2965            
2966            EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
2967            
2968            this.sqlResultSet.updateAsciiStream(1, inputStream, 100);
2969            
2970            this.lock.unlock();
2971            
2972            this.control.replay();
2973            
2974            this.resultSet.updateAsciiStream(1, inputStream, 100);
2975            
2976            this.control.verify();
2977        }
2978        catch (SQLException JavaDoc e)
2979        {
2980            assert false : e;
2981        }
2982    }
2983
2984    /**
2985     * Test method for {@link ResultSet#updateAsciiStream(String, InputStream, int)}
2986     */

2987    public void testUpdateAsciiStreamStringInputStreamInt()
2988    {
2989        InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[] { 1 });
2990        File JavaDoc file = new File JavaDoc("");
2991        
2992        try
2993        {
2994            EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
2995            
2996            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2997            
2998            this.lock.lock();
2999            
3000            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3001            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3002            
3003            EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
3004            
3005            this.sqlResultSet.updateAsciiStream("column", inputStream, 100);
3006            
3007            this.lock.unlock();
3008            
3009            this.control.replay();
3010            
3011            this.resultSet.updateAsciiStream("column", inputStream, 100);
3012            
3013            this.control.verify();
3014        }
3015        catch (SQLException JavaDoc e)
3016        {
3017            assert false : e;
3018        }
3019    }
3020
3021    /**
3022     * Test method for {@link ResultSet#updateBigDecimal(int, BigDecimal)}
3023     */

3024    public void testUpdateBigDecimalIntBigDecimal()
3025    {
3026        BigDecimal JavaDoc decimal = new BigDecimal JavaDoc(1.0);
3027        
3028        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3029        
3030        this.lock.lock();
3031        
3032        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3033        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3034        
3035        try
3036        {
3037            this.sqlResultSet.updateBigDecimal(1, decimal);
3038            
3039            this.lock.unlock();
3040            
3041            this.control.replay();
3042            
3043            this.resultSet.updateBigDecimal(1, decimal);
3044            
3045            this.control.verify();
3046        }
3047        catch (SQLException JavaDoc e)
3048        {
3049            assert false : e;
3050        }
3051    }
3052
3053    /**
3054     * Test method for {@link ResultSet#updateBigDecimal(String, BigDecimal)}
3055     */

3056    public void testUpdateBigDecimalStringBigDecimal()
3057    {
3058        BigDecimal JavaDoc decimal = new BigDecimal JavaDoc(1.0);
3059        
3060        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3061        
3062        this.lock.lock();
3063        
3064        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3065        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3066        
3067        try
3068        {
3069            this.sqlResultSet.updateBigDecimal("column", decimal);
3070            
3071            this.lock.unlock();
3072            
3073            this.control.replay();
3074            
3075            this.resultSet.updateBigDecimal("column", decimal);
3076            
3077            this.control.verify();
3078        }
3079        catch (SQLException JavaDoc e)
3080        {
3081            assert false : e;
3082        }
3083    }
3084
3085    /**
3086     * Test method for {@link ResultSet#updateBinaryStream(int, InputStream, int)}
3087     */

3088    public void testUpdateBinaryStreamIntInputStreamInt()
3089    {
3090        InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[] { 1 });
3091        File JavaDoc file = new File JavaDoc("");
3092        
3093        try
3094        {
3095            EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
3096            
3097            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3098            
3099            this.lock.lock();
3100            
3101            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3102            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3103            
3104            EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
3105            
3106            this.sqlResultSet.updateBinaryStream(1, inputStream, 100);
3107            
3108            this.lock.unlock();
3109            
3110            this.control.replay();
3111            
3112            this.resultSet.updateBinaryStream(1, inputStream, 100);
3113            
3114            this.control.verify();
3115        }
3116        catch (SQLException JavaDoc e)
3117        {
3118            assert false : e;
3119        }
3120    }
3121
3122    /**
3123     * Test method for {@link ResultSet#updateBinaryStream(String, InputStream, int)}
3124     */

3125    public void testUpdateBinaryStreamStringInputStreamInt()
3126    {
3127        InputStream JavaDoc inputStream = new ByteArrayInputStream JavaDoc(new byte[] { 1 });
3128        File JavaDoc file = new File JavaDoc("");
3129        
3130        try
3131        {
3132            EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
3133            
3134            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3135            
3136            this.lock.lock();
3137            
3138            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3139            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3140            
3141            EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
3142            
3143            this.sqlResultSet.updateBinaryStream("column", inputStream, 100);
3144            
3145            this.lock.unlock();
3146            
3147            this.control.replay();
3148            
3149            this.resultSet.updateBinaryStream("column", inputStream, 100);
3150            
3151            this.control.verify();
3152        }
3153        catch (SQLException JavaDoc e)
3154        {
3155            assert false : e;
3156        }
3157    }
3158
3159    /**
3160     * Test method for {@link ResultSet#updateBlob(int, Blob)}
3161     */

3162    public void testUpdateBlobIntBlob()
3163    {
3164        Blob JavaDoc blob = EasyMock.createMock(Blob JavaDoc.class);
3165        File JavaDoc file = new File JavaDoc("");
3166        
3167        try
3168        {
3169            EasyMock.expect(this.fileSupport.createFile(blob)).andReturn(file);
3170            
3171            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3172            
3173            this.lock.lock();
3174            
3175            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3176            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3177            
3178            EasyMock.expect(this.fileSupport.getBlob(file)).andReturn(blob);
3179            
3180            this.sqlResultSet.updateBlob(1, blob);
3181            
3182            this.lock.unlock();
3183            
3184            this.control.replay();
3185            
3186            this.resultSet.updateBlob(1, blob);
3187            
3188            this.control.verify();
3189        }
3190        catch (SQLException JavaDoc e)
3191        {
3192            assert false : e;
3193        }
3194    }
3195
3196    /**
3197     * Test method for {@link ResultSet#updateBlob(String, Blob)}
3198     */

3199    public void testUpdateBlobStringBlob()
3200    {
3201        Blob JavaDoc blob = EasyMock.createMock(Blob JavaDoc.class);
3202        File JavaDoc file = new File JavaDoc("");
3203        
3204        try
3205        {
3206            EasyMock.expect(this.fileSupport.createFile(blob)).andReturn(file);
3207            
3208            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3209            
3210            this.lock.lock();
3211            
3212            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3213            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3214            
3215            EasyMock.expect(this.fileSupport.getBlob(file)).andReturn(blob);
3216            
3217            this.sqlResultSet.updateBlob("column", blob);
3218            
3219            this.lock.unlock();
3220            
3221            this.control.replay();
3222            
3223            this.resultSet.updateBlob("column", blob);
3224            
3225            this.control.verify();
3226        }
3227        catch (SQLException JavaDoc e)
3228        {
3229            assert false : e;
3230        }
3231    }
3232
3233    /**
3234     * Test method for {@link ResultSet#updateBoolean(int, boolean)}
3235     */

3236    public void testUpdateBooleanIntBoolean()
3237    {
3238        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3239        
3240        this.lock.lock();
3241        
3242        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3243        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3244        
3245        try
3246        {
3247            this.sqlResultSet.updateBoolean(1, true);
3248            
3249            this.lock.unlock();
3250            
3251            this.control.replay();
3252            
3253            this.resultSet.updateBoolean(1, true);
3254            
3255            this.control.verify();
3256        }
3257        catch (SQLException JavaDoc e)
3258        {
3259            assert false : e;
3260        }
3261    }
3262
3263    /**
3264     * Test method for {@link ResultSet#updateBoolean(String, boolean)}
3265     */

3266    public void testUpdateBooleanStringBoolean()
3267    {
3268        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3269        
3270        this.lock.lock();
3271        
3272        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3273        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3274        
3275        try
3276        {
3277            this.sqlResultSet.updateBoolean("column", true);
3278            
3279            this.lock.unlock();
3280            
3281            this.control.replay();
3282            
3283            this.resultSet.updateBoolean("column", true);
3284            
3285            this.control.verify();
3286        }
3287        catch (SQLException JavaDoc e)
3288        {
3289            assert false : e;
3290        }
3291    }
3292
3293    /**
3294     * Test method for {@link ResultSet#updateByte(int, byte)}
3295     */

3296    public void testUpdateByteIntByte()
3297    {
3298        byte value = 1;
3299        
3300        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3301        
3302        this.lock.lock();
3303        
3304        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3305        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3306        
3307        try
3308        {
3309            this.sqlResultSet.updateByte(1, value);
3310            
3311            this.lock.unlock();
3312            
3313            this.control.replay();
3314            
3315            this.resultSet.updateByte(1, value);
3316            
3317            this.control.verify();
3318        }
3319        catch (SQLException JavaDoc e)
3320        {
3321            assert false : e;
3322        }
3323    }
3324
3325    /**
3326     * Test method for {@link ResultSet#updateByte(String, byte)}
3327     */

3328    public void testUpdateByteStringByte()
3329    {
3330        byte value = 1;
3331        
3332        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3333        
3334        this.lock.lock();
3335        
3336        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3337        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3338        
3339        try
3340        {
3341            this.sqlResultSet.updateByte("column", value);
3342            
3343            this.lock.unlock();
3344            
3345            this.control.replay();
3346            
3347            this.resultSet.updateByte("column", value);
3348            
3349            this.control.verify();
3350        }
3351        catch (SQLException JavaDoc e)
3352        {
3353            assert false : e;
3354        }
3355    }
3356
3357    /**
3358     * Test method for {@link ResultSet#updateBytes(int, byte[])}
3359     */

3360    public void testUpdateBytesIntByteArray()
3361    {
3362        byte[] value = new byte[] { 1 };
3363        
3364        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3365        
3366        this.lock.lock();
3367        
3368        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3369        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3370        
3371        try
3372        {
3373            this.sqlResultSet.updateBytes(1, value);
3374            
3375            this.lock.unlock();
3376            
3377            this.control.replay();
3378            
3379            this.resultSet.updateBytes(1, value);
3380            
3381            this.control.verify();
3382        }
3383        catch (SQLException JavaDoc e)
3384        {
3385            assert false : e;
3386        }
3387    }
3388
3389    /**
3390     * Test method for {@link ResultSet#updateBytes(String, byte[])}
3391     */

3392    public void testUpdateBytesStringByteArray()
3393    {
3394        byte[] value = new byte[] { 1 };
3395        
3396        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3397        
3398        this.lock.lock();
3399        
3400        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3401        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3402        
3403        try
3404        {
3405            this.sqlResultSet.updateBytes("column", value);
3406            
3407            this.lock.unlock();
3408            
3409            this.control.replay();
3410            
3411            this.resultSet.updateBytes("column", value);
3412            
3413            this.control.verify();
3414        }
3415        catch (SQLException JavaDoc e)
3416        {
3417            assert false : e;
3418        }
3419    }
3420
3421    /**
3422     * Test method for {@link ResultSet#updateCharacterStream(int, Reader, int)}
3423     */

3424    public void testUpdateCharacterStreamIntReaderInt()
3425    {
3426        Reader JavaDoc reader = new StringReader JavaDoc("test");
3427        File JavaDoc file = new File JavaDoc("");
3428        
3429        try
3430        {
3431            EasyMock.expect(this.fileSupport.createFile(reader)).andReturn(file);
3432            
3433            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3434            
3435            this.lock.lock();
3436            
3437            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3438            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3439            
3440            EasyMock.expect(this.fileSupport.getReader(file)).andReturn(reader);
3441            
3442            this.sqlResultSet.updateCharacterStream(1, reader, 100);
3443            
3444            this.lock.unlock();
3445            
3446            this.control.replay();
3447            
3448            this.resultSet.updateCharacterStream(1, reader, 100);
3449            
3450            this.control.verify();
3451        }
3452        catch (SQLException JavaDoc e)
3453        {
3454            assert false : e;
3455        }
3456    }
3457
3458    /**
3459     * Test method for {@link ResultSet#updateCharacterStream(String, Reader, int)}
3460     */

3461    public void testUpdateCharacterStreamStringReaderInt()
3462    {
3463        Reader JavaDoc reader = new StringReader JavaDoc("test");
3464        File JavaDoc file = new File JavaDoc("");
3465        
3466        try
3467        {
3468            EasyMock.expect(this.fileSupport.createFile(reader)).andReturn(file);
3469            
3470            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3471            
3472            this.lock.lock();
3473            
3474            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3475            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3476            
3477            EasyMock.expect(this.fileSupport.getReader(file)).andReturn(reader);
3478            
3479            this.sqlResultSet.updateCharacterStream("column", reader, 100);
3480            
3481            this.lock.unlock();
3482            
3483            this.control.replay();
3484            
3485            this.resultSet.updateCharacterStream("column", reader, 100);
3486            
3487            this.control.verify();
3488        }
3489        catch (SQLException JavaDoc e)
3490        {
3491            assert false : e;
3492        }
3493    }
3494
3495    /**
3496     * Test method for {@link ResultSet#updateClob(int, Clob)}
3497     */

3498    public void testUpdateClobIntClob()
3499    {
3500        Clob JavaDoc clob = EasyMock.createMock(Clob JavaDoc.class);
3501        File JavaDoc file = new File JavaDoc("");
3502        
3503        try
3504        {
3505            EasyMock.expect(this.fileSupport.createFile(clob)).andReturn(file);
3506            
3507            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3508            
3509            this.lock.lock();
3510            
3511            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3512            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3513            
3514            EasyMock.expect(this.fileSupport.getClob(file)).andReturn(clob);
3515            
3516            this.sqlResultSet.updateClob(1, clob);
3517            
3518            this.lock.unlock();
3519            
3520            this.control.replay();
3521            
3522            this.resultSet.updateClob(1, clob);
3523            
3524            this.control.verify();
3525        }
3526        catch (SQLException JavaDoc e)
3527        {
3528            assert false : e;
3529        }
3530    }
3531
3532    /**
3533     * Test method for {@link ResultSet#updateClob(String, Clob)}
3534     */

3535    public void testUpdateClobStringClob()
3536    {
3537        Clob JavaDoc clob = EasyMock.createMock(Clob JavaDoc.class);
3538        File JavaDoc file = new File JavaDoc("");
3539        
3540        try
3541        {
3542            EasyMock.expect(this.fileSupport.createFile(clob)).andReturn(file);
3543            
3544            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3545            
3546            this.lock.lock();
3547            
3548            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3549            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3550            
3551            EasyMock.expect(this.fileSupport.getClob(file)).andReturn(clob);
3552            
3553            this.sqlResultSet.updateClob("column", clob);
3554            
3555            this.lock.unlock();
3556            
3557            this.control.replay();
3558            
3559            this.resultSet.updateClob("column", clob);
3560            
3561            this.control.verify();
3562        }
3563        catch (SQLException JavaDoc e)
3564        {
3565            assert false : e;
3566        }
3567    }
3568
3569    /**
3570     * Test method for {@link ResultSet#updateDate(int, Date)}
3571     */

3572    public void testUpdateDateIntDate()
3573    {
3574        Date JavaDoc date = new Date JavaDoc(System.currentTimeMillis());
3575
3576        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3577        
3578        this.lock.lock();
3579        
3580        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3581        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3582        
3583        try
3584        {
3585            this.sqlResultSet.updateDate(1, date);
3586            
3587            this.lock.unlock();
3588            
3589            this.control.replay();
3590            
3591            this.resultSet.updateDate(1, date);
3592            
3593            this.control.verify();
3594        }
3595        catch (SQLException JavaDoc e)
3596        {
3597            assert false : e;
3598        }
3599    }
3600
3601    /**
3602     * Test method for {@link ResultSet#updateDate(String, Date)}
3603     */

3604    public void testUpdateDateStringDate()
3605    {
3606        Date JavaDoc date = new Date JavaDoc(System.currentTimeMillis());
3607
3608        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3609        
3610        this.lock.lock();
3611        
3612        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3613        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3614        
3615        try
3616        {
3617            this.sqlResultSet.updateDate("column", date);
3618            
3619            this.lock.unlock();
3620            
3621            this.control.replay();
3622            
3623            this.resultSet.updateDate("column", date);
3624            
3625            this.control.verify();
3626        }
3627        catch (SQLException JavaDoc e)
3628        {
3629            assert false : e;
3630        }
3631    }
3632
3633    /**
3634     * Test method for {@link ResultSet#updateDouble(int, double)}
3635     */

3636    public void testUpdateDoubleIntDouble()
3637    {
3638        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3639        
3640        this.lock.lock();
3641        
3642        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3643        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3644        
3645        try
3646        {
3647            this.sqlResultSet.updateDouble(1, 1.1);
3648            
3649            this.lock.unlock();
3650            
3651            this.control.replay();
3652            
3653            this.resultSet.updateDouble(1, 1.1);
3654            
3655            this.control.verify();
3656        }
3657        catch (SQLException JavaDoc e)
3658        {
3659            assert false : e;
3660        }
3661    }
3662
3663    /**
3664     * Test method for {@link ResultSet#updateDouble(String, double)}
3665     */

3666    public void testUpdateDoubleStringDouble()
3667    {
3668        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3669        
3670        this.lock.lock();
3671        
3672        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3673        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3674        
3675        try
3676        {
3677            this.sqlResultSet.updateDouble("column", 1.1);
3678            
3679            this.lock.unlock();
3680            
3681            this.control.replay();
3682            
3683            this.resultSet.updateDouble("column", 1.1);
3684            
3685            this.control.verify();
3686        }
3687        catch (SQLException JavaDoc e)
3688        {
3689            assert false : e;
3690        }
3691    }
3692
3693    /**
3694     * Test method for {@link ResultSet#updateFloat(int, float)}
3695     */

3696    public void testUpdateFloatIntFloat()
3697    {
3698        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3699        
3700        this.lock.lock();
3701        
3702        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3703        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3704        
3705        try
3706        {
3707            this.sqlResultSet.updateFloat(1, 1.1f);
3708            
3709            this.lock.unlock();
3710            
3711            this.control.replay();
3712            
3713            this.resultSet.updateFloat(1, 1.1f);
3714            
3715            this.control.verify();
3716        }
3717        catch (SQLException JavaDoc e)
3718        {
3719            assert false : e;
3720        }
3721    }
3722
3723    /**
3724     * Test method for {@link ResultSet#updateFloat(String, float)}
3725     */

3726    public void testUpdateFloatStringFloat()
3727    {
3728        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3729        
3730        this.lock.lock();
3731        
3732        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3733        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3734        
3735        try
3736        {
3737            this.sqlResultSet.updateFloat("column", 1.1f);
3738            
3739            this.lock.unlock();
3740            
3741            this.control.replay();
3742            
3743            this.resultSet.updateFloat("column", 1.1f);
3744            
3745            this.control.verify();
3746        }
3747        catch (SQLException JavaDoc e)
3748        {
3749            assert false : e;
3750        }
3751    }
3752
3753    /**
3754     * Test method for {@link ResultSet#updateInt(int, int)}
3755     */

3756    public void testUpdateIntIntInt()
3757    {
3758        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3759        
3760        this.lock.lock();
3761        
3762        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3763        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3764        
3765        try
3766        {
3767            this.sqlResultSet.updateInt(1, 1);
3768            
3769            this.lock.unlock();
3770            
3771            this.control.replay();
3772            
3773            this.resultSet.updateInt(1, 1);
3774            
3775            this.control.verify();
3776        }
3777        catch (SQLException JavaDoc e)
3778        {
3779            assert false : e;
3780        }
3781    }
3782
3783    /**
3784     * Test method for {@link ResultSet#updateInt(String, int)}
3785     */

3786    public void testUpdateIntStringInt()
3787    {
3788        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3789        
3790        this.lock.lock();
3791        
3792        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3793        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3794        
3795        try
3796        {
3797            this.sqlResultSet.updateInt("column", 1);;
3798            
3799            this.lock.unlock();
3800            
3801            this.control.replay();
3802            
3803            this.resultSet.updateInt("column", 1);
3804            
3805            this.control.verify();
3806        }
3807        catch (SQLException JavaDoc e)
3808        {
3809            assert false : e;
3810        }
3811    }
3812
3813    /**
3814     * Test method for {@link ResultSet#updateLong(int, long)}
3815     */

3816    public void testUpdateLongIntLong()
3817    {
3818        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3819        
3820        this.lock.lock();
3821        
3822        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3823        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3824        
3825        try
3826        {
3827            this.sqlResultSet.updateLong(1, 1);
3828            
3829            this.lock.unlock();
3830            
3831            this.control.replay();
3832            
3833            this.resultSet.updateLong(1, 1);
3834            
3835            this.control.verify();
3836        }
3837        catch (SQLException JavaDoc e)
3838        {
3839            assert false : e;
3840        }
3841    }
3842
3843    /**
3844     * Test method for {@link ResultSet#updateLong(String, long)}
3845     */

3846    public void testUpdateLongStringLong()
3847    {
3848        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3849        
3850        this.lock.lock();
3851        
3852        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3853        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3854        
3855        try
3856        {
3857            this.sqlResultSet.updateLong("column", 1);
3858            
3859            this.lock.unlock();
3860            
3861            this.control.replay();
3862            
3863            this.resultSet.updateLong("column", 1);
3864            
3865            this.control.verify();
3866        }
3867        catch (SQLException JavaDoc e)
3868        {
3869            assert false : e;
3870        }
3871    }
3872
3873    /**
3874     * Test method for {@link ResultSet#updateNull(int)}
3875     */

3876    public void testUpdateNullInt()
3877    {
3878        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3879        
3880        this.lock.lock();
3881        
3882        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3883        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3884        
3885        try
3886        {
3887            this.sqlResultSet.updateNull(1);
3888            
3889            this.lock.unlock();
3890            
3891            this.control.replay();
3892            
3893            this.resultSet.updateNull(1);
3894            
3895            this.control.verify();
3896        }
3897        catch (SQLException JavaDoc e)
3898        {
3899            assert false : e;
3900        }
3901    }
3902
3903    /**
3904     * Test method for {@link ResultSet#updateNull(String)}
3905     */

3906    public void testUpdateNullString()
3907    {
3908        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3909        
3910        this.lock.lock();
3911        
3912        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3913        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3914        
3915        try
3916        {
3917            this.sqlResultSet.updateNull("column");
3918            
3919            this.lock.unlock();
3920            
3921            this.control.replay();
3922            
3923            this.resultSet.updateNull("column");
3924            
3925            this.control.verify();
3926        }
3927        catch (SQLException JavaDoc e)
3928        {
3929            assert false : e;
3930        }
3931    }
3932
3933    /**
3934     * Test method for {@link ResultSet#updateObject(int, Object)}
3935     */

3936    public void testUpdateObjectIntObject()
3937    {
3938        Object JavaDoc object = new Object JavaDoc();
3939        
3940        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3941        
3942        this.lock.lock();
3943        
3944        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3945        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3946        
3947        try
3948        {
3949            this.sqlResultSet.updateObject(1, object);
3950            
3951            this.lock.unlock();
3952            
3953            this.control.replay();
3954            
3955            this.resultSet.updateObject(1, object);
3956            
3957            this.control.verify();
3958        }
3959        catch (SQLException JavaDoc e)
3960        {
3961            assert false : e;
3962        }
3963    }
3964
3965    /**
3966     * Test method for {@link ResultSet#updateObject(int, Object, int)}
3967     */

3968    public void testUpdateObjectIntObjectInt()
3969    {
3970        Object JavaDoc object = new Object JavaDoc();
3971        
3972        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
3973        
3974        this.lock.lock();
3975        
3976        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
3977        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
3978        
3979        try
3980        {
3981            this.sqlResultSet.updateObject(1, object, Types.ARRAY);
3982            
3983            this.lock.unlock();
3984            
3985            this.control.replay();
3986            
3987            this.resultSet.updateObject(1, object, Types.ARRAY);
3988            
3989            this.control.verify();
3990        }
3991        catch (SQLException JavaDoc e)
3992        {
3993            assert false : e;
3994        }
3995    }
3996
3997    /**
3998     * Test method for {@link ResultSet#updateObject(String, Object)}
3999     */

4000    public void testUpdateObjectStringObject()
4001    {
4002        Object JavaDoc object = new Object JavaDoc();
4003        
4004        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4005        
4006        this.lock.lock();
4007        
4008        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4009        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4010        
4011        try
4012        {
4013            this.sqlResultSet.updateObject("column", object);
4014            
4015            this.lock.unlock();
4016            
4017            this.control.replay();
4018            
4019            this.resultSet.updateObject("column", object);
4020            
4021            this.control.verify();
4022        }
4023        catch (SQLException JavaDoc e)
4024        {
4025            assert false : e;
4026        }
4027    }
4028
4029    /**
4030     * Test method for {@link ResultSet#updateObject(String, Object, int)}
4031     */

4032    public void testUpdateObjectStringObjectInt()
4033    {
4034        Object JavaDoc object = new Object JavaDoc();
4035        
4036        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4037        
4038        this.lock.lock();
4039        
4040        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4041        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4042        
4043        try
4044        {
4045            this.sqlResultSet.updateObject("column", object, Types.ARRAY);
4046            
4047            this.lock.unlock();
4048            
4049            this.control.replay();
4050            
4051            this.resultSet.updateObject("column", object, Types.ARRAY);
4052            
4053            this.control.verify();
4054        }
4055        catch (SQLException JavaDoc e)
4056        {
4057            assert false : e;
4058        }
4059    }
4060
4061    /**
4062     * Test method for {@link ResultSet#updateRef(int, Ref)}
4063     */

4064    public void testUpdateRefIntRef()
4065    {
4066        Ref JavaDoc ref = EasyMock.createMock(Ref JavaDoc.class);
4067        
4068        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4069        
4070        this.lock.lock();
4071        
4072        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4073        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4074        
4075        try
4076        {
4077            this.sqlResultSet.updateObject(1, ref);
4078            
4079            this.lock.unlock();
4080            
4081            this.control.replay();
4082            
4083            this.resultSet.updateObject(1, ref);
4084            
4085            this.control.verify();
4086        }
4087        catch (SQLException JavaDoc e)
4088        {
4089            assert false : e;
4090        }
4091    }
4092
4093    /**
4094     * Test method for {@link ResultSet#updateRef(String, Ref)}
4095     */

4096    public void testUpdateRefStringRef()
4097    {
4098        Ref JavaDoc ref = EasyMock.createMock(Ref JavaDoc.class);
4099        
4100        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4101        
4102        this.lock.lock();
4103        
4104        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4105        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4106        
4107        try
4108        {
4109            this.sqlResultSet.updateObject("column", ref);
4110            
4111            this.lock.unlock();
4112            
4113            this.control.replay();
4114            
4115            this.resultSet.updateObject("column", ref);
4116            
4117            this.control.verify();
4118        }
4119        catch (SQLException JavaDoc e)
4120        {
4121            assert false : e;
4122        }
4123    }
4124
4125    /**
4126     * Test method for {@link ResultSet#updateRow()}
4127     */

4128    public void testUpdateRow()
4129    {
4130        EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
4131        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4132        
4133        this.lock.lock();
4134        
4135        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4136        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4137        
4138        try
4139        {
4140            this.sqlResultSet.updateRow();
4141            
4142            this.lock.unlock();
4143            
4144            this.control.replay();
4145            
4146            this.resultSet.updateRow();
4147            
4148            this.control.verify();
4149        }
4150        catch (SQLException JavaDoc e)
4151        {
4152            assert false : e;
4153        }
4154    }
4155
4156    /**
4157     * Test method for {@link ResultSet#updateShort(int, short)}
4158     */

4159    public void testUpdateShortIntShort()
4160    {
4161        short s = Integer.valueOf(1).shortValue();
4162        
4163        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4164        
4165        this.lock.lock();
4166        
4167        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4168        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4169        
4170        try
4171        {
4172            this.sqlResultSet.updateShort(1, s);
4173            
4174            this.lock.unlock();
4175            
4176            this.control.replay();
4177            
4178            this.resultSet.updateShort(1, s);
4179            
4180            this.control.verify();
4181        }
4182        catch (SQLException JavaDoc e)
4183        {
4184            assert false : e;
4185        }
4186    }
4187
4188    /**
4189     * Test method for {@link ResultSet#updateShort(String, short)}
4190     */

4191    public void testUpdateShortStringShort()
4192    {
4193        short s = Integer.valueOf(1).shortValue();
4194        
4195        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4196        
4197        this.lock.lock();
4198        
4199        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4200        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4201        
4202        try
4203        {
4204            this.sqlResultSet.updateShort("column", s);
4205            
4206            this.lock.unlock();
4207            
4208            this.control.replay();
4209            
4210            this.resultSet.updateShort("column", s);
4211            
4212            this.control.verify();
4213        }
4214        catch (SQLException JavaDoc e)
4215        {
4216            assert false : e;
4217        }
4218    }
4219
4220    /**
4221     * Test method for {@link ResultSet#updateString(int, String)}
4222     */

4223    public void testUpdateStringIntString()
4224    {
4225        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4226        
4227        this.lock.lock();
4228        
4229        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4230        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4231        
4232        try
4233        {
4234            this.sqlResultSet.updateString(1, "test");
4235            
4236            this.lock.unlock();
4237            
4238            this.control.replay();
4239            
4240            this.resultSet.updateString(1, "test");
4241            
4242            this.control.verify();
4243        }
4244        catch (SQLException JavaDoc e)
4245        {
4246            assert false : e;
4247        }
4248    }
4249
4250    /**
4251     * Test method for {@link ResultSet#updateString(String, String)}
4252     */

4253    public void testUpdateStringStringString()
4254    {
4255        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4256        
4257        this.lock.lock();
4258        
4259        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4260        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4261        
4262        try
4263        {
4264            this.sqlResultSet.updateString("column", "test");
4265            
4266            this.lock.unlock();
4267            
4268            this.control.replay();
4269            
4270            this.resultSet.updateString("column", "test");
4271            
4272            this.control.verify();
4273        }
4274        catch (SQLException JavaDoc e)
4275        {
4276            assert false : e;
4277        }
4278    }
4279
4280    /**
4281     * Test method for {@link ResultSet#updateTime(int, Time)}
4282     */

4283    public void testUpdateTimeIntTime()
4284    {
4285        Time JavaDoc time = new Time JavaDoc(System.currentTimeMillis());
4286        
4287        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4288        
4289        this.lock.lock();
4290        
4291        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4292        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4293        
4294        try
4295        {
4296            this.sqlResultSet.updateTime(1, time);
4297            
4298            this.lock.unlock();
4299            
4300            this.control.replay();
4301            
4302            this.resultSet.updateTime(1, time);
4303            
4304            this.control.verify();
4305        }
4306        catch (SQLException JavaDoc e)
4307        {
4308            assert false : e;
4309        }
4310    }
4311
4312    /**
4313     * Test method for {@link ResultSet#updateTime(String, Time)}
4314     */

4315    public void testUpdateTimeStringTime()
4316    {
4317        Time JavaDoc time = new Time JavaDoc(System.currentTimeMillis());
4318        
4319        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4320        
4321        this.lock.lock();
4322        
4323        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4324        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4325        
4326        try
4327        {
4328            this.sqlResultSet.updateTime("column", time);
4329            
4330            this.lock.unlock();
4331            
4332            this.control.replay();
4333            
4334            this.resultSet.updateTime("column", time);
4335            
4336            this.control.verify();
4337        }
4338        catch (SQLException JavaDoc e)
4339        {
4340            assert false : e;
4341        }
4342    }
4343
4344    /**
4345     * Test method for {@link ResultSet#updateTimestamp(int, Timestamp)}
4346     */

4347    public void testUpdateTimestampIntTimestamp()
4348    {
4349        Timestamp JavaDoc timestamp = new Timestamp JavaDoc(System.currentTimeMillis());
4350        
4351        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4352        
4353        this.lock.lock();
4354        
4355        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4356        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4357        
4358        try
4359        {
4360            this.sqlResultSet.updateTimestamp(1, timestamp);
4361            
4362            this.lock.unlock();
4363            
4364            this.control.replay();
4365            
4366            this.resultSet.updateTimestamp(1, timestamp);
4367            
4368            this.control.verify();
4369        }
4370        catch (SQLException JavaDoc e)
4371        {
4372            assert false : e;
4373        }
4374    }
4375
4376    /**
4377     * Test method for {@link ResultSet#updateTimestamp(String, Timestamp)}
4378     */

4379    public void testUpdateTimestampStringTimestamp()
4380    {
4381        Timestamp JavaDoc timestamp = new Timestamp JavaDoc(System.currentTimeMillis());
4382        
4383        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
4384        
4385        this.lock.lock();
4386        
4387        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4388        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
4389        
4390        try
4391        {
4392            this.sqlResultSet.updateTimestamp("column", timestamp);
4393            
4394            this.lock.unlock();
4395            
4396            this.control.replay();
4397            
4398            this.resultSet.updateTimestamp("column", timestamp);
4399            
4400            this.control.verify();
4401        }
4402        catch (SQLException JavaDoc e)
4403        {
4404            assert false : e;
4405        }
4406    }
4407
4408    /**
4409     * Test method for {@link ResultSet#wasNull()}
4410     */

4411    public void testWasNull()
4412    {
4413        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
4414        EasyMock.expect(this.balancer.first()).andReturn(this.database);
4415        
4416        try
4417        {
4418            EasyMock.expect(this.sqlResultSet.wasNull()).andReturn(true);
4419            
4420            this.control.replay();
4421            
4422            boolean wasNull = this.resultSet.wasNull();
4423            
4424            this.control.verify();
4425            
4426            assert wasNull;
4427        }
4428        catch (SQLException JavaDoc e)
4429        {
4430            assert false : e;
4431        }
4432    }
4433}
4434
Popular Tags