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


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.sql.CallableStatement ;
24 import java.sql.DatabaseMetaData ;
25 import java.sql.PreparedStatement ;
26 import java.sql.SQLException ;
27 import java.sql.SQLWarning ;
28 import java.sql.Statement ;
29 import java.util.Collections ;
30 import java.util.List ;
31 import java.util.Map ;
32 import java.util.concurrent.ExecutorService ;
33 import java.util.concurrent.Executors ;
34 import java.util.concurrent.locks.Lock ;
35
36 import net.sf.hajdbc.Balancer;
37 import net.sf.hajdbc.Database;
38 import net.sf.hajdbc.DatabaseCluster;
39 import net.sf.hajdbc.MockDatabase;
40 import net.sf.hajdbc.Operation;
41
42 import org.easymock.EasyMock;
43 import org.easymock.IMocksControl;
44 import org.testng.annotations.AfterMethod;
45 import org.testng.annotations.BeforeClass;
46 import org.testng.annotations.Test;
47
48 /**
49  * Unit test for {@link Connection}
50  * @author Paul Ferraro
51  * @since 1.0
52  */
53 @Test
54 public class TestConnection
55 {
56     private IMocksControl control = EasyMock.createStrictControl();
57     private DatabaseCluster databaseCluster = this.control.createMock(DatabaseCluster.class);
58     private java.sql.Connection sqlConnection = this.control.createMock(java.sql.Connection .class);
59     private Database database = new MockDatabase();
60     private Balancer balancer = this.control.createMock(Balancer.class);
61     private FileSupport fileSupport = this.control.createMock(FileSupport.class);
62     private Connection<java.sql.Connection > connection;
63     private Lock lock = this.control.createMock(Lock .class);
64     private List <Database> databaseList = Collections.singletonList(this.database);
65     private ExecutorService executor = Executors.newSingleThreadExecutor();
66     
67     @BeforeClass
68     public void init() throws Exception
69     {
70         Map map = Collections.singletonMap(this.database, this.sqlConnection);
71         
72         EasyMock.expect(this.databaseCluster.getConnectionFactoryMap()).andReturn(map);
73         EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
74         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
75         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
76         
77         this.control.replay();
78         
79         ConnectionFactory<java.sql.Connection > connectionFactory = new ConnectionFactory<java.sql.Connection >(this.databaseCluster, java.sql.Connection .class);
80         
81         Operation<java.sql.Connection , java.sql.Connection > operation = new Operation<java.sql.Connection , java.sql.Connection >()
82         {
83             public java.sql.Connection execute(Database database, java.sql.Connection connection) throws SQLException
84             {
85                 return connection;
86             }
87         };
88         
89         this.connection = new Connection<java.sql.Connection >(connectionFactory, operation, this.fileSupport);
90
91         this.control.verify();
92         this.control.reset();
93     }
94
95     @AfterMethod
96     public void reset()
97     {
98         this.control.reset();
99     }
100     
101     /**
102      * Test method for {@link Connection#getObject(Database)}
103      */
104     public void testGetObject()
105     {
106         this.control.replay();
107         
108         Object connection = this.connection.getObject(this.database);
109         
110         this.control.verify();
111         
112         assert this.sqlConnection == connection;
113     }
114
115     /**
116      * Test method for {@link Connection#getDatabaseCluster()}
117      */
118     public void testGetDatabaseCluster()
119     {
120         this.control.replay();
121         
122         DatabaseCluster databaseCluster = this.connection.getDatabaseCluster();
123         
124         this.control.verify();
125         
126         assert this.databaseCluster == databaseCluster;
127     }
128
129     /**
130      * Test method for {@link Connection#handleExceptions(Map)}
131      */
132     public void testHandleExceptions()
133     {
134         try
135         {
136             EasyMock.expect(this.databaseCluster.deactivate(this.database)).andReturn(Boolean.FALSE);
137             
138             this.control.replay();
139             
140             this.connection.handleExceptions(Collections.singletonMap(this.database, new SQLException ()));
141             
142             this.control.verify();
143         }
144         catch (SQLException e)
145         {
146             assert false : e;
147         }
148     }
149     
150     /**
151      * Test method for {@link Connection#clearWarnings()}
152      */
153     public void testClearWarnings()
154     {
155         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
156         
157         this.lock.lock();
158         
159         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
160         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
161         
162         try
163         {
164             this.sqlConnection.clearWarnings();
165             
166             this.lock.unlock();
167             
168             this.control.replay();
169             
170             this.connection.clearWarnings();
171             
172             this.control.verify();
173         }
174         catch (SQLException e)
175         {
176             assert false : e;
177         }
178     }
179
180     /**
181      * Test method for {@link Connection#close()}
182      */
183     public void testClose()
184     {
185         EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
186         
187         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
188         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
189         
190         try
191         {
192             this.sqlConnection.close();
193             
194             this.fileSupport.close();
195             
196             this.control.replay();
197             
198             this.connection.close();
199             
200             this.control.verify();
201         }
202         catch (SQLException e)
203         {
204             assert false : e;
205         }
206     }
207
208     /**
209      * Test method for {@link Connection#commit()}
210      */
211     public void testCommit()
212     {
213         EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
214         
215         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
216         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
217         
218         try
219         {
220             this.sqlConnection.commit();
221             
222             this.control.replay();
223             
224             this.connection.commit();
225             
226             this.control.verify();
227         }
228         catch (SQLException e)
229         {
230             assert false : e;
231         }
232     }
233
234     /**
235      * Test method for {@link Connection#createStatement()}
236      */
237     public void testCreateStatement()
238     {
239         Statement sqlStatement = EasyMock.createMock(Statement.class);
240
241         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
242         EasyMock.expect(this.balancer.first()).andReturn(this.database);
243
244         try
245         {
246             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(Boolean.FALSE);
247             
248             EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
249             
250             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
251             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
252             
253             EasyMock.expect(this.sqlConnection.createStatement()).andReturn(sqlStatement);
254             
255             this.control.replay();
256             
257             Statement statement = this.connection.createStatement();
258             
259             this.control.verify();
260             
261             assert net.sf.hajdbc.sql.Statement.class.cast(statement).getObject(this.database) == sqlStatement;
262         }
263         catch (SQLException e)
264         {
265             assert false : e;
266         }
267     }
268
269     /**
270      * Test method for {@link Connection#createStatement()}
271      */
272     public void testReadOnlyCreateStatement()
273     {
274         Statement sqlStatement = EasyMock.createMock(Statement.class);
275
276         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
277         EasyMock.expect(this.balancer.first()).andReturn(this.database);
278         
279         try
280         {
281             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(Boolean.TRUE);
282             
283             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
284             EasyMock.expect(this.balancer.first()).andReturn(this.database);
285             
286             EasyMock.expect(this.sqlConnection.createStatement()).andReturn(sqlStatement);
287
288             this.control.replay();
289             
290             Statement statement = this.connection.createStatement();
291             
292             this.control.verify();
293             
294             assert sqlStatement == statement;
295         }
296         catch (SQLException e)
297         {
298             assert false : e;
299         }
300     }
301
302     /**
303      * Test method for {@link Connection#createStatement(int, int)}
304      */
305     public void testCreateStatementIntInt()
306     {
307         Statement sqlStatement = EasyMock.createMock(Statement.class);
308
309         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
310         EasyMock.expect(this.balancer.first()).andReturn(this.database);
311
312         try
313         {
314             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
315             
316             EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
317             
318             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
319             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
320             
321             EasyMock.expect(this.sqlConnection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)).andReturn(sqlStatement);
322             
323             this.control.replay();
324             
325             Statement statement = this.connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
326             
327             this.control.verify();
328             
329             assert net.sf.hajdbc.sql.Statement.class.cast(statement).getObject(this.database) == sqlStatement;
330         }
331         catch (SQLException e)
332         {
333             assert false : e;
334         }
335     }
336
337     /**
338      * Test method for {@link Connection#createStatement(int, int)}
339      */
340     public void testReadOnlyCreateStatementIntInt()
341     {
342         Statement sqlStatement = EasyMock.createMock(Statement.class);
343
344         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
345         EasyMock.expect(this.balancer.first()).andReturn(this.database);
346
347         try
348         {
349             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
350             
351             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
352             EasyMock.expect(this.balancer.first()).andReturn(this.database);
353
354             EasyMock.expect(this.sqlConnection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)).andReturn(sqlStatement);
355             
356             this.control.replay();
357             
358             Statement statement = this.connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
359             
360             this.control.verify();
361             
362             assert sqlStatement == statement;
363         }
364         catch (SQLException e)
365         {
366             assert false : e;
367         }
368     }
369
370     /**
371      * Test method for {@link Connection#createStatement(int, int, int)}
372      */
373     public void testCreateStatementIntIntInt()
374     {
375         Statement sqlStatement = EasyMock.createMock(Statement.class);
376
377         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
378         EasyMock.expect(this.balancer.first()).andReturn(this.database);
379
380         try
381         {
382             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
383             
384             EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
385             
386             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
387             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
388             
389             EasyMock.expect(this.sqlConnection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE)).andReturn(sqlStatement);
390             
391             this.control.replay();
392             
393             Statement statement = this.connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE);
394             
395             this.control.verify();
396             
397             assert net.sf.hajdbc.sql.Statement.class.cast(statement).getObject(this.database) == sqlStatement;
398         }
399         catch (SQLException e)
400         {
401             assert false : e;
402         }
403     }
404
405     /**
406      * Test method for {@link Connection#createStatement(int, int, int)}
407      */
408     public void testReadOnlyCreateStatementIntIntInt()
409     {
410         Statement sqlStatement = EasyMock.createMock(Statement.class);
411
412         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
413         EasyMock.expect(this.balancer.first()).andReturn(this.database);
414
415         try
416         {
417             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
418             
419             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
420             EasyMock.expect(this.balancer.first()).andReturn(this.database);
421
422             EasyMock.expect(this.sqlConnection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE)).andReturn(sqlStatement);
423             
424             this.control.replay();
425             
426             Statement statement = this.connection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE);
427             
428             this.control.verify();
429             
430             assert sqlStatement == statement;
431         }
432         catch (SQLException e)
433         {
434             assert false : e;
435         }
436     }
437
438     /**
439      * Test method for {@link Connection#getAutoCommit()}
440      */
441     public void testGetAutoCommit()
442     {
443         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
444         EasyMock.expect(this.balancer.first()).andReturn(this.database);
445         
446         try
447         {
448             EasyMock.expect(this.sqlConnection.getAutoCommit()).andReturn(true);
449             
450             this.control.replay();
451             
452             boolean autoCommit = this.connection.getAutoCommit();
453             
454             this.control.verify();
455             
456             assert autoCommit;
457         }
458         catch (SQLException e)
459         {
460             assert false : e;
461         }
462     }
463
464     /**
465      * Test method for {@link Connection#getCatalog()}
466      */
467     public void testGetCatalog()
468     {
469         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
470         EasyMock.expect(this.balancer.next()).andReturn(this.database);
471         
472         try
473         {
474             this.balancer.beforeOperation(this.database);
475             
476             EasyMock.expect(this.sqlConnection.getCatalog()).andReturn("test");
477             
478             this.balancer.afterOperation(this.database);
479             
480             this.control.replay();
481             
482             String catalog = this.connection.getCatalog();
483             
484             this.control.verify();
485             
486             assert catalog.equals("test") : catalog;
487         }
488         catch (SQLException e)
489         {
490             assert false : e;
491         }
492     }
493
494     /**
495      * Test method for {@link Connection#getHoldability()}
496      */
497     public void testGetHoldability()
498     {
499         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
500         EasyMock.expect(this.balancer.first()).andReturn(this.database);
501         
502         try
503         {
504             EasyMock.expect(this.sqlConnection.getHoldability()).andReturn(ResultSet.HOLD_CURSORS_OVER_COMMIT);
505             
506             this.control.replay();
507             
508             int holdability = this.connection.getHoldability();
509             
510             this.control.verify();
511             
512             assert holdability == ResultSet.HOLD_CURSORS_OVER_COMMIT : holdability;
513         }
514         catch (SQLException e)
515         {
516             assert false : e;
517         }
518     }
519
520     /**
521      * Test method for {@link Connection#getMetaData()}
522      */
523     public void testGetMetaData()
524     {
525         DatabaseMetaData databaseMetaData = EasyMock.createMock(DatabaseMetaData .class);
526         
527         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
528         EasyMock.expect(this.balancer.next()).andReturn(this.database);
529         
530         try
531         {
532             this.balancer.beforeOperation(this.database);
533             
534             EasyMock.expect(this.sqlConnection.getMetaData()).andReturn(databaseMetaData);
535             
536             this.balancer.afterOperation(this.database);
537             
538             this.control.replay();
539             
540             DatabaseMetaData metaData = this.connection.getMetaData();
541             
542             this.control.verify();
543             
544             assert databaseMetaData == metaData;
545         }
546         catch (SQLException e)
547         {
548             assert false : e;
549         }
550     }
551
552     /**
553      * Test method for {@link Connection#getTransactionIsolation()}
554      */
555     public void testGetTransactionIsolation()
556     {
557         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
558         EasyMock.expect(this.balancer.next()).andReturn(this.database);
559         
560         try
561         {
562             this.balancer.beforeOperation(this.database);
563             
564             EasyMock.expect(this.sqlConnection.getTransactionIsolation()).andReturn(Connection.TRANSACTION_NONE);
565             
566             this.balancer.afterOperation(this.database);
567             
568             this.control.replay();
569             
570             int transactionIsolation = this.connection.getTransactionIsolation();
571             
572             this.control.verify();
573             
574             assert transactionIsolation == Connection.TRANSACTION_NONE : transactionIsolation;
575         }
576         catch (SQLException e)
577         {
578             assert false : e;
579         }
580     }
581
582     /**
583      * Test method for {@link Connection#getTypeMap()}
584      */
585     public void testGetTypeMap()
586     {
587         Map typeMap = EasyMock.createMock(Map .class);
588         
589         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
590         EasyMock.expect(this.balancer.first()).andReturn(this.database);
591         
592         try
593         {
594             EasyMock.expect(this.sqlConnection.getTypeMap()).andReturn(typeMap);
595             
596             this.control.replay();
597             
598             Map map = this.connection.getTypeMap();
599             
600             this.control.verify();
601             
602             assert map == typeMap;
603         }
604         catch (SQLException e)
605         {
606             assert false : e;
607         }
608     }
609
610     /**
611      * Test method for {@link Connection#getWarnings()}
612      */
613     public void testGetWarnings()
614     {
615         SQLWarning sqlWarning = new SQLWarning ();
616         
617         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
618         EasyMock.expect(this.balancer.first()).andReturn(this.database);
619         
620         try
621         {
622             EasyMock.expect(this.sqlConnection.getWarnings()).andReturn(sqlWarning);
623             
624             this.control.replay();
625             
626             SQLWarning warning = this.connection.getWarnings();
627             
628             this.control.verify();
629             
630             assert warning == sqlWarning;
631         }
632         catch (SQLException e)
633         {
634             assert false : e;
635         }
636     }
637
638     /**
639      * Test method for {@link Connection#isClosed()}
640      */
641     public void testIsClosed()
642     {
643         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
644         EasyMock.expect(this.balancer.first()).andReturn(this.database);
645         
646         try
647         {
648             EasyMock.expect(this.sqlConnection.isClosed()).andReturn(true);
649             
650             this.control.replay();
651             
652             boolean closed = this.connection.isClosed();
653             
654             this.control.verify();
655             
656             assert closed;
657         }
658         catch (SQLException e)
659         {
660             assert false : e;
661         }
662     }
663
664     /**
665      * Test method for {@link Connection#isReadOnly()}
666      */
667     public void testIsReadOnly()
668     {
669         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
670         EasyMock.expect(this.balancer.first()).andReturn(this.database);
671         
672         try
673         {
674             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
675             
676             this.control.replay();
677             
678             boolean readOnly = this.connection.isReadOnly();
679             
680             this.control.verify();
681             
682             assert readOnly;
683         }
684         catch (SQLException e)
685         {
686             assert false : e;
687         }
688     }
689
690     /**
691      * Test method for {@link Connection#nativeSQL(String)}
692      */
693     public void testNativeSQL()
694     {
695         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
696         EasyMock.expect(this.balancer.first()).andReturn(this.database);
697         
698         try
699         {
700             EasyMock.expect(this.sqlConnection.nativeSQL("test")).andReturn("SELECT 'test'");
701             
702             this.control.replay();
703             
704             String nativeSQL = this.connection.nativeSQL("test");
705             
706             this.control.verify();
707             
708             assert nativeSQL.equals("SELECT 'test'") : nativeSQL;
709         }
710         catch (SQLException e)
711         {
712             assert false : e;
713         }
714     }
715
716     /**
717      * Test method for {@link Connection#prepareCall(String)}
718      */
719     public void testPrepareCallString()
720     {
721         CallableStatement sqlStatement = EasyMock.createMock(CallableStatement.class);
722
723         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
724         EasyMock.expect(this.balancer.first()).andReturn(this.database);
725
726         try
727         {
728             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
729
730             EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
731             
732             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
733             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
734             
735             EasyMock.expect(this.sqlConnection.prepareCall("CALL ME")).andReturn(sqlStatement);
736             
737             this.control.replay();
738             
739             CallableStatement statement = this.connection.prepareCall("CALL ME");
740             
741             this.control.verify();
742             
743             assert net.sf.hajdbc.sql.CallableStatement.class.cast(statement).getObject(this.database) == sqlStatement;
744         }
745         catch (SQLException e)
746         {
747             assert false : e;
748         }
749     }
750
751     /**
752      * Test method for {@link Connection#prepareCall(String)}
753      */
754     public void testReadOnlyPrepareCallString()
755     {
756         CallableStatement sqlStatement = EasyMock.createMock(CallableStatement.class);
757
758         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
759         EasyMock.expect(this.balancer.first()).andReturn(this.database);
760
761         try
762         {
763             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
764             
765             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
766             EasyMock.expect(this.balancer.next()).andReturn(this.database);
767
768             this.balancer.beforeOperation(this.database);
769             
770             EasyMock.expect(this.sqlConnection.prepareCall("CALL ME")).andReturn(sqlStatement);
771             
772             this.balancer.afterOperation(this.database);
773             
774             this.control.replay();
775             
776             CallableStatement statement = this.connection.prepareCall("CALL ME");
777             
778             this.control.verify();
779             
780             assert sqlStatement == statement;
781         }
782         catch (SQLException e)
783         {
784             assert false : e;
785         }
786     }
787
788     /**
789      * Test method for {@link Connection#prepareCall(String, int, int)}
790      */
791     public void testPrepareCallStringIntInt()
792     {
793         CallableStatement sqlStatement = EasyMock.createMock(CallableStatement.class);
794
795         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
796         EasyMock.expect(this.balancer.first()).andReturn(this.database);
797
798         try
799         {
800             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
801             
802             EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
803             
804             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
805             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
806                         
807             EasyMock.expect(this.sqlConnection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)).andReturn(sqlStatement);
808             
809             this.control.replay();
810             
811             CallableStatement statement = this.connection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
812             
813             this.control.verify();
814             
815             assert net.sf.hajdbc.sql.CallableStatement.class.cast(statement).getObject(this.database) == sqlStatement;
816         }
817         catch (SQLException e)
818         {
819             assert false : e;
820         }
821     }
822
823     /**
824      * Test method for {@link Connection#prepareCall(String, int, int)}
825      */
826     public void testReadOnlyPrepareCallStringIntInt()
827     {
828         CallableStatement sqlStatement = EasyMock.createMock(CallableStatement.class);
829
830         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
831         EasyMock.expect(this.balancer.first()).andReturn(this.database);
832
833         try
834         {
835             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
836             
837             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
838             EasyMock.expect(this.balancer.next()).andReturn(this.database);
839
840             this.balancer.beforeOperation(this.database);
841             
842             EasyMock.expect(this.sqlConnection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)).andReturn(sqlStatement);
843             
844             this.balancer.afterOperation(this.database);
845             
846             this.control.replay();
847             
848             CallableStatement statement = this.connection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
849             
850             this.control.verify();
851             
852             assert statement == sqlStatement;
853         }
854         catch (SQLException e)
855         {
856             assert false : e;
857         }
858     }
859
860     /**
861      * Test method for {@link Connection#prepareCall(String, int, int, int)}
862      */
863     public void testPrepareCallStringIntIntInt()
864     {
865         CallableStatement sqlStatement = EasyMock.createMock(CallableStatement.class);
866
867         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
868         EasyMock.expect(this.balancer.first()).andReturn(this.database);
869
870         try
871         {
872             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
873             
874             EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
875             
876             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
877             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
878             
879             EasyMock.expect(this.sqlConnection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE)).andReturn(sqlStatement);
880             
881             this.control.replay();
882             
883             CallableStatement statement = this.connection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE);
884             
885             this.control.verify();
886             
887             assert net.sf.hajdbc.sql.CallableStatement.class.cast(statement).getObject(this.database) == sqlStatement;
888         }
889         catch (SQLException e)
890         {
891             assert false : e;
892         }
893     }
894
895     /**
896      * Test method for {@link Connection#prepareCall(String, int, int, int)}
897      */
898     public void testReadOnlyPrepareCallStringIntIntInt()
899     {
900         CallableStatement sqlStatement = EasyMock.createMock(CallableStatement.class);
901
902         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
903         EasyMock.expect(this.balancer.first()).andReturn(this.database);
904
905         try
906         {
907             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
908             
909             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
910             EasyMock.expect(this.balancer.next()).andReturn(this.database);
911
912             this.balancer.beforeOperation(this.database);
913             
914             EasyMock.expect(this.sqlConnection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE)).andReturn(sqlStatement);
915             
916             this.balancer.afterOperation(this.database);
917             
918             this.control.replay();
919             
920             CallableStatement statement = this.connection.prepareCall("CALL ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE);
921             
922             this.control.verify();
923             
924             assert sqlStatement == statement;
925         }
926         catch (SQLException e)
927         {
928             assert false : e;
929         }
930     }
931
932     /**
933      * Test method for {@link Connection#prepareStatement(String)}
934      */
935     public void testPrepareStatementString()
936     {
937         PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
938
939         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
940         EasyMock.expect(this.balancer.first()).andReturn(this.database);
941
942         try
943         {
944             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
945             
946             EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
947             
948             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
949             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
950                         
951             EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME")).andReturn(sqlStatement);
952             
953             this.control.replay();
954             
955             PreparedStatement statement = this.connection.prepareStatement("SELECT ME");
956             
957             this.control.verify();
958             
959             assert net.sf.hajdbc.sql.PreparedStatement.class.cast(statement).getObject(this.database) == sqlStatement;
960         }
961         catch (SQLException e)
962         {
963             assert false : e;
964         }
965     }
966
967     /**
968      * Test method for {@link Connection#prepareStatement(String)}
969      */
970     public void testReadOnlyPrepareStatementString()
971     {
972         PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
973
974         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
975         EasyMock.expect(this.balancer.first()).andReturn(this.database);
976
977         try
978         {
979             EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
980             
981             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
982             EasyMock.expect(this.balancer.next()).andReturn(this.database);
983
984             this.balancer.beforeOperation(this.database);
985             
986             EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME")).andReturn(sqlStatement);
987             
988             this.balancer.afterOperation(this.database);
989             
990             this.control.replay();
991             
992             PreparedStatement statement = this.connection.prepareStatement("SELECT ME");
993             
994             this.control.verify();
995             
996             assert statement == sqlStatement;
997         }
998         catch (SQLException e)
999         {
1000            assert false : e;
1001        }
1002    }
1003
1004    /**
1005     * Test method for {@link Connection#prepareStatement(String, int)}
1006     */
1007    public void testPrepareStatementStringInt()
1008    {
1009        PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
1010
1011        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1012        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1013
1014        try
1015        {
1016            EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
1017            
1018            EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1019            
1020            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1021            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1022            
1023            EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME")).andReturn(sqlStatement);
1024            
1025            this.control.replay();
1026            
1027            PreparedStatement statement = this.connection.prepareStatement("SELECT ME");
1028            
1029            this.control.verify();
1030            
1031            assert net.sf.hajdbc.sql.PreparedStatement.class.cast(statement).getObject(this.database) == sqlStatement;
1032        }
1033        catch (SQLException e)
1034        {
1035            assert false : e;
1036        }
1037    }
1038
1039    /**
1040     * Test method for {@link Connection#prepareStatement(String, int)}
1041     */
1042    public void testReadOnlyPrepareStatementStringInt()
1043    {
1044        PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
1045
1046        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1047        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1048
1049        try
1050        {
1051            EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
1052            
1053            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1054            EasyMock.expect(this.balancer.next()).andReturn(this.database);
1055
1056            this.balancer.beforeOperation(this.database);
1057            
1058            EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME")).andReturn(sqlStatement);
1059            
1060            this.balancer.afterOperation(this.database);
1061            
1062            this.control.replay();
1063            
1064            PreparedStatement statement = this.connection.prepareStatement("SELECT ME");
1065            
1066            this.control.verify();
1067            
1068            assert statement == sqlStatement;
1069        }
1070        catch (SQLException e)
1071        {
1072            assert false : e;
1073        }
1074    }
1075
1076    /**
1077     * Test method for {@link Connection#prepareStatement(String, int, int)}
1078     */
1079    public void testPrepareStatementStringIntInt()
1080    {
1081        PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
1082        
1083        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1084        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1085
1086        try
1087        {
1088            EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
1089            
1090            EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1091            
1092            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1093            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1094            
1095            EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)).andReturn(sqlStatement);
1096            
1097            this.control.replay();
1098            
1099            PreparedStatement statement = this.connection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
1100            
1101            this.control.verify();
1102            
1103            assert net.sf.hajdbc.sql.PreparedStatement.class.cast(statement).getObject(this.database) == sqlStatement;
1104        }
1105        catch (SQLException e)
1106        {
1107            assert false : e;
1108        }
1109    }
1110
1111    /**
1112     * Test method for {@link Connection#prepareStatement(String, int, int)}
1113     */
1114    public void testReadOnlyPrepareStatementStringIntInt()
1115    {
1116        PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
1117
1118        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1119        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1120
1121        try
1122        {
1123            EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
1124            
1125            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1126            EasyMock.expect(this.balancer.next()).andReturn(this.database);
1127
1128            this.balancer.beforeOperation(this.database);
1129            
1130            EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE)).andReturn(sqlStatement);
1131            
1132            this.balancer.afterOperation(this.database);
1133            
1134            this.control.replay();
1135            
1136            PreparedStatement statement = this.connection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE);
1137            
1138            this.control.verify();
1139            
1140            assert statement == sqlStatement;
1141        }
1142        catch (SQLException e)
1143        {
1144            assert false : e;
1145        }
1146    }
1147
1148    /**
1149     * Test method for {@link Connection#prepareStatement(String, int, int, int)}
1150     */
1151    public void testPrepareStatementStringIntIntInt()
1152    {
1153        PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
1154
1155        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1156        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1157
1158        try
1159        {
1160            EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(false);
1161            
1162            EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1163            
1164            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1165            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1166            
1167            EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE)).andReturn(sqlStatement);
1168            
1169            this.control.replay();
1170            
1171            PreparedStatement statement = this.connection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE);
1172            
1173            this.control.verify();
1174            
1175            assert net.sf.hajdbc.sql.PreparedStatement.class.cast(statement).getObject(this.database) == sqlStatement;
1176        }
1177        catch (SQLException e)
1178        {
1179            assert false : e;
1180        }
1181    }
1182
1183    /**
1184     * Test method for {@link Connection#prepareStatement(String, int, int, int)}
1185     */
1186    public void testReadOnlyPrepareStatementStringIntIntInt()
1187    {
1188        PreparedStatement sqlStatement = EasyMock.createMock(PreparedStatement.class);
1189
1190        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1191        EasyMock.expect(this.balancer.first()).andReturn(this.database);
1192
1193        try
1194        {
1195            EasyMock.expect(this.sqlConnection.isReadOnly()).andReturn(true);
1196            
1197            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1198            EasyMock.expect(this.balancer.next()).andReturn(this.database);
1199
1200            this.balancer.beforeOperation(this.database);
1201            
1202            EasyMock.expect(this.sqlConnection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE)).andReturn(sqlStatement);
1203            
1204            this.balancer.afterOperation(this.database);
1205            
1206            this.control.replay();
1207            
1208            PreparedStatement statement = this.connection.prepareStatement("SELECT ME", ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE, ResultSet.FETCH_REVERSE);
1209            
1210            this.control.verify();
1211            
1212            assert statement == sqlStatement;
1213        }
1214        catch (SQLException e)
1215        {
1216            assert false : e;
1217        }
1218    }
1219
1220    /**
1221     * Test method for {@link Connection#releaseSavepoint(java.sql.Savepoint)}
1222     */
1223    public void testReleaseSavepoint()
1224    {
1225        final java.sql.Savepoint sqlSavepoint = EasyMock.createMock(java.sql.Savepoint .class);
1226        
1227        Operation<java.sql.Connection , java.sql.Savepoint > operation = new Operation<java.sql.Connection , java.sql.Savepoint >()
1228        {
1229            public java.sql.Savepoint execute(Database database, java.sql.Connection connection) throws SQLException
1230            {
1231                return sqlSavepoint;
1232            }
1233        };
1234        
1235        EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
1236        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1237        
1238        this.lock.lock();
1239        
1240        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1241        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1242
1243        this.lock.unlock();
1244        
1245        this.control.replay();
1246        
1247        try
1248        {
1249            Savepoint savepoint = new Savepoint(this.connection, operation);
1250            
1251            this.control.verify();
1252            this.control.reset();
1253
1254            EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
1255            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1256            
1257            this.lock.lock();
1258            
1259            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1260            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1261            
1262            this.sqlConnection.releaseSavepoint(savepoint);
1263            
1264            this.lock.unlock();
1265            
1266            this.control.replay();
1267            
1268            this.connection.releaseSavepoint(savepoint);
1269            
1270            this.control.verify();
1271        }
1272        catch (SQLException e)
1273        {
1274            assert false : e;
1275        }
1276    }
1277
1278    /**
1279     * Test method for {@link Connection#rollback()}
1280     */
1281    public void testRollback()
1282    {
1283        EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1284        
1285        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1286        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1287        
1288        try
1289        {
1290            this.sqlConnection.rollback();
1291            
1292            this.control.replay();
1293            
1294            this.connection.rollback();
1295            
1296            this.control.verify();
1297        }
1298        catch (SQLException e)
1299        {
1300            assert false : e;
1301        }
1302    }
1303
1304    /**
1305     * Test method for {@link Connection#rollback(java.sql.Savepoint)}
1306     */
1307    public void testRollbackSavepoint()
1308    {
1309        final java.sql.Savepoint sqlSavepoint = EasyMock.createMock(java.sql.Savepoint .class);
1310        
1311        Operation<java.sql.Connection , java.sql.Savepoint > operation = new Operation<java.sql.Connection , java.sql.Savepoint >()
1312        {
1313            public java.sql.Savepoint execute(Database database, java.sql.Connection connection) throws SQLException
1314            {
1315                return sqlSavepoint;
1316            }
1317        };
1318        
1319        EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
1320        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1321        
1322        this.lock.lock();
1323        
1324        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1325        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1326
1327        this.lock.unlock();
1328        
1329        this.control.replay();
1330        
1331        try
1332        {
1333            Savepoint savepoint = new Savepoint(this.connection, operation);
1334            
1335            this.control.verify();
1336            this.control.reset();
1337            
1338            EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
1339            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1340            
1341            this.lock.lock();
1342            
1343            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1344            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1345            
1346            this.sqlConnection.rollback(savepoint);
1347
1348            this.lock.unlock();
1349            
1350            this.control.replay();
1351            
1352            this.connection.rollback(savepoint);
1353            
1354            this.control.verify();
1355        }
1356        catch (SQLException e)
1357        {
1358            assert false : e;
1359        }
1360    }
1361
1362    /**
1363     * Test method for {@link Connection#setAutoCommit(boolean)}
1364     */
1365    public void testSetAutoCommit()
1366    {
1367        EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1368        
1369        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1370        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1371        
1372        try
1373        {
1374            this.sqlConnection.setAutoCommit(true);
1375            
1376            this.control.replay();
1377            
1378            this.connection.setAutoCommit(true);
1379            
1380            this.control.verify();
1381        }
1382        catch (SQLException e)
1383        {
1384            assert false : e;
1385        }
1386    }
1387
1388    /**
1389     * Test method for {@link Connection#setCatalog(String)}
1390     */
1391    public void testSetCatalog()
1392    {
1393        EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1394        
1395        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1396        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1397        
1398        try
1399        {
1400            this.sqlConnection.setCatalog("test");
1401            
1402            this.control.replay();
1403            
1404            this.connection.setCatalog("test");
1405            
1406            this.control.verify();
1407        }
1408        catch (SQLException e)
1409        {
1410            assert false : e;
1411        }
1412    }
1413
1414    /**
1415     * Test method for {@link Connection#setHoldability(int)}
1416     */
1417    public void testSetHoldability()
1418    {
1419        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1420        
1421        this.lock.lock();
1422        
1423        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1424        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1425        
1426        try
1427        {
1428            this.sqlConnection.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
1429            
1430            this.lock.unlock();
1431            
1432            this.control.replay();
1433            
1434            this.connection.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT);
1435            
1436            this.control.verify();
1437        }
1438        catch (SQLException e)
1439        {
1440            assert false : e;
1441        }
1442    }
1443
1444    /**
1445     * Test method for {@link Connection#setReadOnly(boolean)}
1446     */
1447    public void testSetReadOnly()
1448    {
1449        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1450        
1451        this.lock.lock();
1452        
1453        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1454        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1455        
1456        try
1457        {
1458            this.sqlConnection.setReadOnly(true);
1459            
1460            this.lock.unlock();
1461            
1462            this.control.replay();
1463            
1464            this.connection.setReadOnly(true);
1465            
1466            this.control.verify();
1467        }
1468        catch (SQLException e)
1469        {
1470            assert false : e;
1471        }
1472    }
1473
1474    /**
1475     * Test method for {@link Connection#setSavepoint()}
1476     */
1477    public void testSetSavepoint()
1478    {
1479        java.sql.Savepoint sqlSavepoint = EasyMock.createMock(java.sql.Savepoint .class);
1480        
1481        EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
1482        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1483        
1484        this.lock.lock();
1485        
1486        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1487        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1488        
1489        try
1490        {
1491            EasyMock.expect(this.sqlConnection.setSavepoint()).andReturn(sqlSavepoint);
1492            
1493            this.lock.unlock();
1494            
1495            this.control.replay();
1496            
1497            java.sql.Savepoint savepoint = this.connection.setSavepoint();
1498            
1499            this.control.verify();
1500            
1501            assert net.sf.hajdbc.sql.Savepoint.class.cast(savepoint).getObject(this.database) == sqlSavepoint;
1502        }
1503        catch (SQLException e)
1504        {
1505            assert false : e;
1506        }
1507    }
1508
1509    /**
1510     * Test method for {@link Connection#setSavepoint()}
1511     */
1512    public void testSetSavepointString()
1513    {
1514        java.sql.Savepoint sqlSavepoint = EasyMock.createMock(java.sql.Savepoint .class);
1515        
1516        EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
1517        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1518        
1519        this.lock.lock();
1520        
1521        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1522        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1523        
1524        try
1525        {
1526            EasyMock.expect(this.sqlConnection.setSavepoint("test")).andReturn(sqlSavepoint);
1527            
1528            this.lock.unlock();
1529            
1530            this.control.replay();
1531            
1532            java.sql.Savepoint savepoint = this.connection.setSavepoint("test");
1533            
1534            this.control.verify();
1535            
1536            assert net.sf.hajdbc.sql.Savepoint.class.cast(savepoint).getObject(this.database) == sqlSavepoint;
1537        }
1538        catch (SQLException e)
1539        {
1540            assert false : e;
1541        }
1542    }
1543
1544    /**
1545     * Test method for {@link Connection#setTransactionIsolation(int)}
1546     */
1547    public void testSetTransactionIsolation()
1548    {
1549        EasyMock.expect(this.databaseCluster.getNonTransactionalExecutor()).andReturn(this.executor);
1550        
1551        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1552        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1553        
1554        try
1555        {
1556            this.sqlConnection.setTransactionIsolation(Connection.TRANSACTION_NONE);
1557            
1558            this.control.replay();
1559            
1560            this.connection.setTransactionIsolation(Connection.TRANSACTION_NONE);
1561            
1562            this.control.verify();
1563        }
1564        catch (SQLException e)
1565        {
1566            assert false : e;
1567        }
1568    }
1569
1570    /**
1571     * Test method for {@link Connection#setTypeMap(Map)}
1572     */
1573    public void testSetTypeMap()
1574    {
1575        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1576        
1577        this.lock.lock();
1578        
1579        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1580        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1581        
1582        try
1583        {
1584            this.sqlConnection.setTypeMap(Collections.EMPTY_MAP);
1585            
1586            this.lock.unlock();
1587            
1588            this.control.replay();
1589            
1590            this.connection.setTypeMap(Collections.EMPTY_MAP);
1591            
1592            this.control.verify();
1593        }
1594        catch (SQLException e)
1595        {
1596            assert false : e;
1597        }
1598    }
1599}
1600

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags