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


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 ;
24 import java.io.File ;
25 import java.io.InputStream ;
26 import java.io.Reader ;
27 import java.io.StringReader ;
28 import java.math.BigDecimal ;
29 import java.net.URL ;
30 import java.sql.Array ;
31 import java.sql.Blob ;
32 import java.sql.Clob ;
33 import java.sql.DatabaseMetaData ;
34 import java.sql.Date ;
35 import java.sql.ParameterMetaData ;
36 import java.sql.Ref ;
37 import java.sql.ResultSet ;
38 import java.sql.ResultSetMetaData ;
39 import java.sql.SQLException ;
40 import java.sql.Time ;
41 import java.sql.Timestamp ;
42 import java.sql.Types ;
43 import java.util.Calendar ;
44
45 import net.sf.hajdbc.Database;
46 import net.sf.hajdbc.Operation;
47
48 import org.easymock.EasyMock;
49 import org.testng.annotations.Test;
50
51 /**
52  * Unit test for {@link PreparedStatement}
53  * @author Paul Ferraro
54  * @since 1.1
55  */
56 @Test
57 public class TestPreparedStatement extends TestStatement
58 {
59     /**
60      * @see net.sf.hajdbc.sql.TestStatement#createStatement(net.sf.hajdbc.sql.Connection)
61      */
62     protected Statement createStatement(Connection connection) throws SQLException
63     {
64         Operation<java.sql.Connection , java.sql.PreparedStatement > operation = new Operation<java.sql.Connection , java.sql.PreparedStatement >()
65         {
66             public java.sql.PreparedStatement execute(Database database, java.sql.Connection connection) throws SQLException
67             {
68                 return TestPreparedStatement.this.getSQLStatement();
69             }
70         };
71         
72         return new PreparedStatement(connection, operation, "");
73     }
74     
75     private PreparedStatement getStatement()
76     {
77         return PreparedStatement.class.cast(this.statement);
78     }
79
80     protected java.sql.PreparedStatement getSQLStatement()
81     {
82         return java.sql.PreparedStatement .class.cast(this.sqlStatement);
83     }
84
85     protected Class <? extends java.sql.Statement > getStatementClass()
86     {
87         return java.sql.PreparedStatement .class;
88     }
89     
90     /**
91      * Test method for {@link PreparedStatement#addBatch()}
92      */
93     public void testAddBatch()
94     {
95         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
96         
97         this.lock.lock();
98         
99         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
100         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
101         
102         try
103         {
104             this.getSQLStatement().addBatch("test");
105             
106             this.lock.unlock();
107             
108             this.control.replay();
109             
110             this.getStatement().addBatch("test");
111             
112             this.control.verify();
113         }
114         catch (SQLException e)
115         {
116             assert false : e;
117         }
118     }
119
120     /**
121      * Test method for {@link PreparedStatement#clearParameters()}
122      */
123     public void testClearParameters()
124     {
125         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
126         
127         this.lock.lock();
128         
129         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
130         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
131         
132         try
133         {
134             this.getSQLStatement().clearParameters();
135             
136             this.lock.unlock();
137             
138             this.control.replay();
139             
140             this.getStatement().clearParameters();
141             
142             this.control.verify();
143         }
144         catch (SQLException e)
145         {
146             assert false : e;
147         }
148     }
149
150     /**
151      * Test method for {@link PreparedStatement#execute()}
152      */
153     public void testExecute()
154     {
155         EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
156         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
157         
158         this.lock.lock();
159         
160         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
161         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
162         
163         try
164         {
165             EasyMock.expect(this.getSQLStatement().execute()).andReturn(true);
166             
167             this.lock.unlock();
168             
169             this.control.replay();
170             
171             boolean success = this.getStatement().execute();
172             
173             this.control.verify();
174             
175             assert success;
176         }
177         catch (SQLException e)
178         {
179             assert false : e;
180         }
181     }
182
183     /**
184      * Test method for {@link PreparedStatement#executeQuery()}
185      */
186     public void testExecuteQuery()
187     {
188         ResultSet resultSet = EasyMock.createMock(ResultSet.class);
189         DatabaseMetaData metaData = EasyMock.createMock(DatabaseMetaData .class);
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.getSQLStatement().getResultSetConcurrency()).andReturn(ResultSet.CONCUR_READ_ONLY);
197
198             EasyMock.expect(this.databaseCluster.getDialect()).andReturn(this.dialect);
199             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
200             EasyMock.expect(this.balancer.next()).andReturn(this.database);
201             
202             this.balancer.beforeOperation(this.database);
203             
204             EasyMock.expect(this.sqlConnection.getMetaData()).andReturn(metaData);
205             
206             this.balancer.afterOperation(this.database);
207             
208             EasyMock.expect(this.dialect.isSelectForUpdate(metaData, "")).andReturn(false);
209             
210             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
211             EasyMock.expect(this.balancer.next()).andReturn(this.database);
212             
213             this.balancer.beforeOperation(this.database);
214             
215             EasyMock.expect(this.getSQLStatement().executeQuery()).andReturn(resultSet);
216             
217             this.balancer.afterOperation(this.database);
218             
219             this.control.replay();
220             
221             ResultSet rs = this.getStatement().executeQuery();
222             
223             this.control.verify();
224             
225             assert rs == resultSet;
226         }
227         catch (SQLException e)
228         {
229             assert false : e;
230         }
231     }
232
233     /**
234      * Test method for {@link PreparedStatement#executeQuery()}
235      */
236     public void testUpdatableExecuteQuery()
237     {
238         ResultSet resultSet = EasyMock.createMock(ResultSet.class);
239         
240         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
241         EasyMock.expect(this.balancer.first()).andReturn(this.database);
242         
243         try
244         {
245             EasyMock.expect(this.getSQLStatement().getResultSetConcurrency()).andReturn(ResultSet.CONCUR_UPDATABLE);
246             
247             EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
248             EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
249             
250             this.lock.lock();
251             
252             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
253             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
254             
255             EasyMock.expect(this.getSQLStatement().executeQuery()).andReturn(resultSet);
256             
257             this.lock.unlock();
258             
259             this.control.replay();
260             
261             ResultSet rs = this.getStatement().executeQuery();
262             
263             this.control.verify();
264             
265             assert net.sf.hajdbc.sql.ResultSet.class.cast(rs).getObject(this.database) == resultSet;
266         }
267         catch (SQLException e)
268         {
269             assert false : e;
270         }
271     }
272
273     /**
274      * Test method for {@link PreparedStatement#executeUpdate()}
275      */
276     public void testExecuteUpdate()
277     {
278         EasyMock.expect(this.databaseCluster.getTransactionalExecutor()).andReturn(this.executor);
279         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
280         
281         this.lock.lock();
282         
283         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
284         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
285         
286         try
287         {
288             EasyMock.expect(this.getSQLStatement().executeUpdate()).andReturn(1);
289             
290             this.lock.unlock();
291             
292             this.control.replay();
293             
294             int result = this.getStatement().executeUpdate();
295             
296             this.control.verify();
297             
298             assert result == 1 : result;
299         }
300         catch (SQLException e)
301         {
302             assert false : e;
303         }
304     }
305
306     /**
307      * Test method for {@link PreparedStatement#getMetaData()}
308      */
309     public void testGetMetaData()
310     {
311         ResultSetMetaData metaData = EasyMock.createMock(ResultSetMetaData .class);
312         
313         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
314         EasyMock.expect(this.balancer.next()).andReturn(this.database);
315         
316         this.balancer.beforeOperation(this.database);
317         
318         try
319         {
320             EasyMock.expect(this.getSQLStatement().getMetaData()).andReturn(metaData);
321             
322             this.balancer.afterOperation(this.database);
323             
324             this.control.replay();
325             
326             ResultSetMetaData result = this.getStatement().getMetaData();
327             
328             this.control.verify();
329             
330             assert result == metaData;
331         }
332         catch (SQLException e)
333         {
334             assert false : e;
335         }
336     }
337
338     /**
339      * Test method for {@link PreparedStatement#getParameterMetaData()}
340      */
341     public void testGetParameterMetaData()
342     {
343         ParameterMetaData metaData = EasyMock.createMock(ParameterMetaData .class);
344         
345         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
346         EasyMock.expect(this.balancer.next()).andReturn(this.database);
347         
348         this.balancer.beforeOperation(this.database);
349         
350         try
351         {
352             EasyMock.expect(this.getSQLStatement().getParameterMetaData()).andReturn(metaData);
353             
354             this.balancer.afterOperation(this.database);
355             
356             this.control.replay();
357             
358             ParameterMetaData result = this.getStatement().getParameterMetaData();
359             
360             this.control.verify();
361             
362             assert result == metaData;
363         }
364         catch (SQLException e)
365         {
366             assert false : e;
367         }
368     }
369
370     /**
371      * Test method for {@link PreparedStatement#setArray(int, Array)}
372      */
373     public void testSetArray()
374     {
375         Array array = EasyMock.createMock(Array .class);
376         
377         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
378         
379         this.lock.lock();
380         
381         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
382         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
383         
384         try
385         {
386             this.getSQLStatement().setArray(1, array);
387             
388             this.lock.unlock();
389             
390             this.control.replay();
391             
392             this.getStatement().setArray(1, array);
393             
394             this.control.verify();
395         }
396         catch (SQLException e)
397         {
398             assert false : e;
399         }
400     }
401
402     /**
403      * Test method for {@link PreparedStatement#setAsciiStream(int, InputStream, int)}
404      */
405     public void testSetAsciiStream()
406     {
407         InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 });
408         File file = new File ("");
409         
410         try
411         {
412             EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
413             
414             EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
415             
416             this.lock.lock();
417             
418             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
419             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
420             
421             EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
422             
423             this.getSQLStatement().setAsciiStream(1, inputStream, 10);
424             
425             this.lock.unlock();
426             
427             this.control.replay();
428             
429             this.getStatement().setAsciiStream(1, inputStream, 10);
430             
431             this.control.verify();
432         }
433         catch (SQLException e)
434         {
435             assert false : e;
436         }
437     }
438
439     /**
440      * Test method for {@link PreparedStatement#setBigDecimal(int, BigDecimal)}
441      */
442     public void testSetBigDecimal()
443     {
444         BigDecimal decimal = new BigDecimal (1.0);
445         
446         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
447         
448         this.lock.lock();
449         
450         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
451         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
452         
453         try
454         {
455             this.getSQLStatement().setBigDecimal(1, decimal);
456             
457             this.lock.unlock();
458             
459             this.control.replay();
460             
461             this.getStatement().setBigDecimal(1, decimal);
462             
463             this.control.verify();
464         }
465         catch (SQLException e)
466         {
467             assert false : e;
468         }
469     }
470
471     /**
472      * Test method for {@link PreparedStatement#setBinaryStream(int, InputStream, int)}
473      */
474     public void testSetBinaryStream()
475     {
476         InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 });
477         File file = new File ("");
478         
479         try
480         {
481             EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
482             
483             EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
484             
485             this.lock.lock();
486             
487             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
488             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
489             
490             EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
491             
492             this.getSQLStatement().setBinaryStream(1, inputStream, 10);
493             
494             this.lock.unlock();
495             
496             this.control.replay();
497             
498             this.getStatement().setBinaryStream(1, inputStream, 10);
499             
500             this.control.verify();
501         }
502         catch (SQLException e)
503         {
504             assert false : e;
505         }
506     }
507
508     /**
509      * Test method for {@link PreparedStatement#setBlob(int, Blob)}
510      */
511     public void testSetBlob()
512     {
513         Blob blob = EasyMock.createMock(Blob .class);
514         File file = new File ("");
515         
516         try
517         {
518             EasyMock.expect(this.fileSupport.createFile(blob)).andReturn(file);
519             EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
520             
521             this.lock.lock();
522             
523             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
524             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
525             
526             EasyMock.expect(this.fileSupport.getBlob(file)).andReturn(blob);
527             
528             this.getSQLStatement().setBlob(1, blob);
529             
530             this.lock.unlock();
531             
532             this.control.replay();
533             
534             this.getStatement().setBlob(1, blob);
535             
536             this.control.verify();
537         }
538         catch (SQLException e)
539         {
540             assert false : e;
541         }
542     }
543
544     /**
545      * Test method for {@link PreparedStatement#setBoolean(int, boolean)}
546      */
547     public void testSetBoolean()
548     {
549         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
550         
551         this.lock.lock();
552         
553         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
554         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
555         
556         try
557         {
558             this.getSQLStatement().setBoolean(1, true);
559             
560             this.lock.unlock();
561             
562             this.control.replay();
563             
564             this.getStatement().setBoolean(1, true);
565             
566             this.control.verify();
567         }
568         catch (SQLException e)
569         {
570             assert false : e;
571         }
572     }
573
574     /**
575      * Test method for {@link PreparedStatement#setByte(int, byte)}
576      */
577     public void testSetByte()
578     {
579         byte value = 1;
580         
581         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
582         
583         this.lock.lock();
584         
585         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
586         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
587         
588         try
589         {
590             this.getSQLStatement().setByte(1, value);
591             
592             this.lock.unlock();
593             
594             this.control.replay();
595             
596             this.getStatement().setByte(1, value);
597             
598             this.control.verify();
599         }
600         catch (SQLException e)
601         {
602             assert false : e;
603         }
604     }
605
606     /**
607      * Test method for {@link PreparedStatement#setBytes(int, byte[])}
608      */
609     public void testSetBytes()
610     {
611         byte[] bytes = new byte[] { 1 };
612         
613         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
614         
615         this.lock.lock();
616         
617         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
618         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
619         
620         try
621         {
622             this.getSQLStatement().setBytes(1, bytes);
623             
624             this.lock.unlock();
625             
626             this.control.replay();
627             
628             this.getStatement().setBytes(1, bytes);
629             
630             this.control.verify();
631         }
632         catch (SQLException e)
633         {
634             assert false : e;
635         }
636     }
637
638     /**
639      * Test method for {@link PreparedStatement#setCharacterStream(int, Reader, int)}
640      */
641     public void testSetCharacterStream()
642     {
643         Reader reader = new StringReader ("test");
644         File file = new File ("");
645         
646         try
647         {
648             EasyMock.expect(this.fileSupport.createFile(reader)).andReturn(file);
649             EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
650             
651             this.lock.lock();
652             
653             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
654             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
655             
656             EasyMock.expect(this.fileSupport.getReader(file)).andReturn(reader);
657             
658             this.getSQLStatement().setCharacterStream(1, reader, 10);
659             
660             this.lock.unlock();
661             
662             this.control.replay();
663             
664             this.getStatement().setCharacterStream(1, reader, 10);
665             
666             this.control.verify();
667         }
668         catch (SQLException e)
669         {
670             assert false : e;
671         }
672     }
673
674     /**
675      * Test method for {@link PreparedStatement#setClob(int, Clob)}
676      */
677     public void testSetClob()
678     {
679         Clob clob = EasyMock.createMock(Clob .class);
680         File file = new File ("");
681         
682         try
683         {
684             EasyMock.expect(this.fileSupport.createFile(clob)).andReturn(file);
685             EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
686             
687             this.lock.lock();
688             
689             EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
690             EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
691             EasyMock.expect(this.fileSupport.getClob(file)).andReturn(clob);
692             
693             this.getSQLStatement().setClob(1, clob);
694             
695             this.lock.unlock();
696             
697             this.control.replay();
698             
699             this.getStatement().setClob(1, clob);
700             
701             this.control.verify();
702         }
703         catch (SQLException e)
704         {
705             assert false : e;
706         }
707     }
708
709     /**
710      * Test method for {@link PreparedStatement#setDate(int, Date)}
711      */
712     public void testSetDateIntDate()
713     {
714         Date date = new Date (System.currentTimeMillis());
715         
716         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
717         
718         this.lock.lock();
719         
720         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
721         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
722         
723         try
724         {
725             this.getSQLStatement().setDate(1, date);
726             
727             this.lock.unlock();
728             
729             this.control.replay();
730             
731             this.getStatement().setDate(1, date);
732             
733             this.control.verify();
734         }
735         catch (SQLException e)
736         {
737             assert false : e;
738         }
739     }
740
741     /**
742      * Test method for {@link PreparedStatement#setDate(int, Date, Calendar)}
743      */
744     public void testSetDateIntDateCalendar()
745     {
746         Date date = new Date (System.currentTimeMillis());
747         Calendar calendar = Calendar.getInstance();
748         
749         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
750         
751         this.lock.lock();
752         
753         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
754         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
755         
756         try
757         {
758             this.getSQLStatement().setDate(1, date, calendar);
759             
760             this.lock.unlock();
761             
762             this.control.replay();
763             
764             this.getStatement().setDate(1, date, calendar);
765             
766             this.control.verify();
767         }
768         catch (SQLException e)
769         {
770             assert false : e;
771         }
772     }
773
774     /**
775      * Test method for {@link PreparedStatement#setDouble(int, double)}
776      */
777     public void testSetDouble()
778     {
779         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
780         
781         this.lock.lock();
782         
783         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
784         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
785         
786         try
787         {
788             this.getSQLStatement().setDouble(1, 1.0);
789             
790             this.lock.unlock();
791             
792             this.control.replay();
793             
794             this.getStatement().setDouble(1, 1.0);
795             
796             this.control.verify();
797         }
798         catch (SQLException e)
799         {
800             assert false : e;
801         }
802     }
803
804     /**
805      * Test method for {@link PreparedStatement#setFloat(int, float)}
806      */
807     public void testSetFloat()
808     {
809         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
810         
811         this.lock.lock();
812         
813         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
814         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
815         
816         try
817         {
818             this.getSQLStatement().setFloat(1, 1.0f);
819             
820             this.lock.unlock();
821             
822             this.control.replay();
823             
824             this.getStatement().setFloat(1, 1.0f);
825             
826             this.control.verify();
827         }
828         catch (SQLException e)
829         {
830             assert false : e;
831         }
832     }
833
834     /**
835      * Test method for {@link PreparedStatement#setInt(int, int)}
836      */
837     public void testSetInt()
838     {
839         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
840         
841         this.lock.lock();
842         
843         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
844         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
845         
846         try
847         {
848             this.getSQLStatement().setInt(1, 1);
849             
850             this.lock.unlock();
851             
852             this.control.replay();
853             
854             this.getStatement().setInt(1, 1);
855             
856             this.control.verify();
857         }
858         catch (SQLException e)
859         {
860             assert false : e;
861         }
862     }
863
864     /**
865      * Test method for {@link PreparedStatement#setLong(int, long)}
866      */
867     public void testSetLong()
868     {
869         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
870         
871         this.lock.lock();
872         
873         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
874         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
875         
876         try
877         {
878             this.getSQLStatement().setLong(1, 1);
879             
880             this.lock.unlock();
881             
882             this.control.replay();
883             
884             this.getStatement().setLong(1, 1);
885             
886             this.control.verify();
887         }
888         catch (SQLException e)
889         {
890             assert false : e;
891         }
892     }
893
894     /**
895      * Test method for {@link PreparedStatement#setNull(int, int)}
896      */
897     public void testSetNullIntInt()
898     {
899         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
900         
901         this.lock.lock();
902         
903         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
904         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
905         
906         try
907         {
908             this.getSQLStatement().setNull(1, Types.ARRAY);
909             
910             this.lock.unlock();
911             
912             this.control.replay();
913             
914             this.getStatement().setNull(1, Types.ARRAY);
915             
916             this.control.verify();
917         }
918         catch (SQLException e)
919         {
920             assert false : e;
921         }
922     }
923
924     /**
925      * Test method for {@link PreparedStatement#setNull(int, int, String)}
926      */
927     public void testSetNullIntIntString()
928     {
929         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
930         
931         this.lock.lock();
932         
933         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
934         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
935         
936         try
937         {
938             this.getSQLStatement().setNull(1, Types.JAVA_OBJECT, "test");
939             
940             this.lock.unlock();
941             
942             this.control.replay();
943             
944             this.getStatement().setNull(1, Types.JAVA_OBJECT, "test");
945             
946             this.control.verify();
947         }
948         catch (SQLException e)
949         {
950             assert false : e;
951         }
952     }
953
954     /**
955      * Test method for {@link PreparedStatement#setObject(int, Object)}
956      */
957     public void testSetObjectIntObject()
958     {
959         Object object = new Object ();
960         
961         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
962         
963         this.lock.lock();
964         
965         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
966         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
967         
968         try
969         {
970             this.getSQLStatement().setObject(1, object);
971             
972             this.lock.unlock();
973             
974             this.control.replay();
975             
976             this.getStatement().setObject(1, object);
977             
978             this.control.verify();
979         }
980         catch (SQLException e)
981         {
982             assert false : e;
983         }
984     }
985
986     /**
987      * Test method for {@link PreparedStatement#setObject(int, Object, int)}
988      */
989     public void testSetObjectIntObjectInt()
990     {
991         Object object = new Object ();
992         
993         EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
994         
995         this.lock.lock();
996         
997         EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
998         EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
999         
1000        try
1001        {
1002            this.getSQLStatement().setObject(1, object, Types.ARRAY);
1003            
1004            this.lock.unlock();
1005            
1006            this.control.replay();
1007            
1008            this.getStatement().setObject(1, object, Types.ARRAY);
1009            
1010            this.control.verify();
1011        }
1012        catch (SQLException e)
1013        {
1014            assert false : e;
1015        }
1016    }
1017
1018    /**
1019     * Test method for {@link PreparedStatement#setObject(int, Object, int, int)}
1020     */
1021    public void testSetObjectIntObjectIntInt()
1022    {
1023        Object object = new Object ();
1024        
1025        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1026        
1027        this.lock.lock();
1028        
1029        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1030        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1031        
1032        try
1033        {
1034            this.getSQLStatement().setObject(1, object, Types.NUMERIC, 10);
1035            
1036            this.lock.unlock();
1037            
1038            this.control.replay();
1039            
1040            this.getStatement().setObject(1, object, Types.NUMERIC, 10);
1041            
1042            this.control.verify();
1043        }
1044        catch (SQLException e)
1045        {
1046            assert false : e;
1047        }
1048    }
1049
1050    /**
1051     * Test method for {@link PreparedStatement#setRef(int, Ref)}
1052     */
1053    public void testSetRef()
1054    {
1055        Ref ref = EasyMock.createMock(Ref .class);
1056        
1057        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1058        
1059        this.lock.lock();
1060        
1061        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1062        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1063        
1064        try
1065        {
1066            this.getSQLStatement().setRef(1, ref);
1067            
1068            this.lock.unlock();
1069            
1070            this.control.replay();
1071            
1072            this.getStatement().setRef(1, ref);
1073            
1074            this.control.verify();
1075        }
1076        catch (SQLException e)
1077        {
1078            assert false : e;
1079        }
1080    }
1081
1082    /**
1083     * Test method for {@link PreparedStatement#setShort(int, short)}
1084     */
1085    public void testSetShort()
1086    {
1087        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1088        
1089        this.lock.lock();
1090        
1091        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1092        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1093        
1094        try
1095        {
1096            this.getSQLStatement().setShort(1, (short) 1);
1097            
1098            this.lock.unlock();
1099            
1100            this.control.replay();
1101            
1102            this.getStatement().setShort(1, (short) 1);
1103            
1104            this.control.verify();
1105        }
1106        catch (SQLException e)
1107        {
1108            assert false : e;
1109        }
1110    }
1111
1112    /**
1113     * Test method for {@link PreparedStatement#setString(int, String)}
1114     */
1115    public void testSetString()
1116    {
1117        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1118        
1119        this.lock.lock();
1120        
1121        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1122        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1123        
1124        try
1125        {
1126            this.getSQLStatement().setString(1, "test");
1127            
1128            this.lock.unlock();
1129            
1130            this.control.replay();
1131            
1132            this.getStatement().setString(1, "test");
1133            
1134            this.control.verify();
1135        }
1136        catch (SQLException e)
1137        {
1138            assert false : e;
1139        }
1140    }
1141
1142    /**
1143     * Test method for {@link PreparedStatement#setTime(int, Time)}
1144     */
1145    public void testSetTimeIntTime()
1146    {
1147        Time time = new Time (System.currentTimeMillis());
1148        
1149        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1150        
1151        this.lock.lock();
1152        
1153        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1154        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1155        
1156        try
1157        {
1158            this.getSQLStatement().setTime(1, time);
1159            
1160            this.lock.unlock();
1161            
1162            this.control.replay();
1163            
1164            this.getStatement().setTime(1, time);
1165            
1166            this.control.verify();
1167        }
1168        catch (SQLException e)
1169        {
1170            assert false : e;
1171        }
1172    }
1173
1174    /**
1175     * Test method for {@link PreparedStatement#setTime(int, Time, Calendar)}
1176     */
1177    public void testSetTimeIntTimeCalendar()
1178    {
1179        Time time = new Time (System.currentTimeMillis());
1180        Calendar calendar = Calendar.getInstance();
1181        
1182        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1183        
1184        this.lock.lock();
1185        
1186        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1187        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1188        
1189        try
1190        {
1191            this.getSQLStatement().setTime(1, time, calendar);
1192            
1193            this.lock.unlock();
1194            
1195            this.control.replay();
1196            
1197            this.getStatement().setTime(1, time, calendar);
1198            
1199            this.control.verify();
1200        }
1201        catch (SQLException e)
1202        {
1203            assert false : e;
1204        }
1205    }
1206
1207    /**
1208     * Test method for {@link PreparedStatement#setTimestamp(int, Timestamp)}
1209     */
1210    public void testSetTimestampIntTimestamp()
1211    {
1212        Timestamp timestamp = new Timestamp (System.currentTimeMillis());
1213        
1214        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1215        
1216        this.lock.lock();
1217        
1218        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1219        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1220        
1221        try
1222        {
1223            this.getSQLStatement().setTimestamp(1, timestamp);
1224            
1225            this.lock.unlock();
1226            
1227            this.control.replay();
1228            
1229            this.getStatement().setTimestamp(1, timestamp);
1230            
1231            this.control.verify();
1232        }
1233        catch (SQLException e)
1234        {
1235            assert false : e;
1236        }
1237    }
1238
1239    /**
1240     * Test method for {@link PreparedStatement#setTimestamp(int, Timestamp, Calendar)}
1241     */
1242    public void testSetTimestampIntTimestampCalendar()
1243    {
1244        Timestamp timestamp = new Timestamp (System.currentTimeMillis());
1245        Calendar calendar = Calendar.getInstance();
1246        
1247        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1248        
1249        this.lock.lock();
1250        
1251        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1252        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1253        
1254        try
1255        {
1256            this.getSQLStatement().setTimestamp(1, timestamp, calendar);
1257            
1258            this.lock.unlock();
1259            
1260            this.control.replay();
1261            
1262            this.getStatement().setTimestamp(1, timestamp, calendar);
1263            
1264            this.control.verify();
1265        }
1266        catch (SQLException e)
1267        {
1268            assert false : e;
1269        }
1270    }
1271
1272    /**
1273     * Test method for {@link PreparedStatement#setUnicodeStream(int, InputStream, int)}
1274     * @deprecated
1275     */
1276    public void testSetUnicodeStream()
1277    {
1278        InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 });
1279        File file = new File ("");
1280        
1281        try
1282        {
1283            EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
1284            EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1285            
1286            this.lock.lock();
1287            
1288            EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1289            EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1290            
1291            EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
1292            
1293            this.getSQLStatement().setUnicodeStream(1, inputStream, 100);
1294            
1295            this.lock.unlock();
1296            
1297            this.control.replay();
1298            
1299            this.getStatement().setUnicodeStream(1, inputStream, 100);
1300            
1301            this.control.verify();
1302        }
1303        catch (SQLException e)
1304        {
1305            assert false : e;
1306        }
1307    }
1308
1309    /**
1310     * Test method for {@link PreparedStatement#setURL(int, URL)}
1311     */
1312    public void testSetURL()
1313    {
1314        EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1315        
1316        this.lock.lock();
1317        
1318        EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1319        EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1320        
1321        try
1322        {
1323            URL url = new URL ("http://www.google.com");
1324            
1325            this.getSQLStatement().setURL(1, url);
1326            
1327            this.lock.unlock();
1328            
1329            this.control.replay();
1330            
1331            this.getStatement().setURL(1, url);
1332            
1333            this.control.verify();
1334        }
1335        catch (Exception e)
1336        {
1337            assert false : e;
1338        }
1339    }
1340}
1341

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags