|
1
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.Date ;
34 import java.sql.Ref ;
35 import java.sql.SQLException ;
36 import java.sql.Time ;
37 import java.sql.Timestamp ;
38 import java.sql.Types ;
39 import java.util.Calendar ;
40 import java.util.Collections ;
41 import java.util.Map ;
42
43 import org.easymock.EasyMock;
44 import org.testng.annotations.Test;
45
46 import net.sf.hajdbc.Database;
47 import net.sf.hajdbc.Operation;
48
49
55 @Test
56 public class TestCallableStatement extends TestPreparedStatement
57 {
58
61 protected Statement createStatement(Connection connection) throws SQLException
62 {
63 Operation<java.sql.Connection , java.sql.CallableStatement > operation = new Operation<java.sql.Connection , java.sql.CallableStatement >()
64 {
65 public java.sql.CallableStatement execute(Database database, java.sql.Connection connection) throws SQLException
66 {
67 return TestCallableStatement.this.getSQLStatement();
68 }
69 };
70
71 return new CallableStatement(connection, operation, "");
72 }
73
74
77 protected Class < ? extends java.sql.Statement > getStatementClass()
78 {
79 return java.sql.CallableStatement .class;
80 }
81
82 private CallableStatement getStatement()
83 {
84 return CallableStatement.class.cast(this.statement);
85 }
86
87 protected java.sql.CallableStatement getSQLStatement()
88 {
89 return java.sql.CallableStatement .class.cast(this.sqlStatement);
90 }
91
92
95 public void testGetArrayInt()
96 {
97 Array array = EasyMock.createMock(Array .class);
98
99 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
100 EasyMock.expect(this.balancer.first()).andReturn(this.database);
101
102 try
103 {
104 EasyMock.expect(this.getSQLStatement().getArray(1)).andReturn(array);
105
106 this.control.replay();
107
108 Array value = this.getStatement().getArray(1);
109
110 this.control.verify();
111
112 assert value == array;
113 }
114 catch (SQLException e)
115 {
116 assert false : e;
117 }
118 }
119
120
123 public void testGetArrayString()
124 {
125 Array array = EasyMock.createMock(Array .class);
126
127 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
128 EasyMock.expect(this.balancer.first()).andReturn(this.database);
129
130 try
131 {
132 EasyMock.expect(this.getSQLStatement().getArray("column")).andReturn(array);
133
134 this.control.replay();
135
136 Array value = this.getStatement().getArray("column");
137
138 this.control.verify();
139
140 assert value == array;
141 }
142 catch (SQLException e)
143 {
144 assert false : e;
145 }
146 }
147
148
151 public void testGetBigDecimalInt()
152 {
153 BigDecimal decimal = new BigDecimal (1.1);
154
155 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
156 EasyMock.expect(this.balancer.first()).andReturn(this.database);
157
158 try
159 {
160 EasyMock.expect(this.getSQLStatement().getBigDecimal(1)).andReturn(decimal);
161
162 this.control.replay();
163
164 BigDecimal value = this.getStatement().getBigDecimal(1);
165
166 this.control.verify();
167
168 assert value == decimal;
169 }
170 catch (SQLException e)
171 {
172 assert false : e;
173 }
174 }
175
176
180 public void testGetBigDecimalIntInt()
181 {
182 BigDecimal decimal = new BigDecimal (1.1);
183
184 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
185 EasyMock.expect(this.balancer.first()).andReturn(this.database);
186
187 try
188 {
189 EasyMock.expect(this.getSQLStatement().getBigDecimal(1, 10)).andReturn(decimal);
190
191 this.control.replay();
192
193 BigDecimal value = this.getStatement().getBigDecimal(1, 10);
194
195 this.control.verify();
196
197 assert value == decimal;
198 }
199 catch (SQLException e)
200 {
201 assert false : e;
202 }
203 }
204
205
208 public void testGetBigDecimalString()
209 {
210 BigDecimal decimal = new BigDecimal (1.1);
211
212 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
213 EasyMock.expect(this.balancer.first()).andReturn(this.database);
214
215 try
216 {
217 EasyMock.expect(this.getSQLStatement().getBigDecimal("column")).andReturn(decimal);
218
219 this.control.replay();
220
221 BigDecimal value = this.getStatement().getBigDecimal("column");
222
223 this.control.verify();
224
225 assert value == decimal;
226 }
227 catch (SQLException e)
228 {
229 assert false : e;
230 }
231 }
232
233
236 public void testGetBlobInt()
237 {
238 Blob blob = EasyMock.createMock(Blob .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().getBlob(1)).andReturn(blob);
246
247 this.control.replay();
248
249 Blob value = this.getStatement().getBlob(1);
250
251 this.control.verify();
252
253 assert value == blob;
254 }
255 catch (SQLException e)
256 {
257 assert false : e;
258 }
259 }
260
261
264 public void testGetBlobString()
265 {
266 Blob blob = EasyMock.createMock(Blob .class);
267
268 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
269 EasyMock.expect(this.balancer.first()).andReturn(this.database);
270
271 try
272 {
273 EasyMock.expect(this.getSQLStatement().getBlob("column")).andReturn(blob);
274
275 this.control.replay();
276
277 Blob value = this.getStatement().getBlob("column");
278
279 this.control.verify();
280
281 assert value == blob;
282 }
283 catch (SQLException e)
284 {
285 assert false : e;
286 }
287 }
288
289
292 public void testGetBooleanInt()
293 {
294 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
295 EasyMock.expect(this.balancer.first()).andReturn(this.database);
296
297 try
298 {
299 EasyMock.expect(this.getSQLStatement().getBoolean(1)).andReturn(true);
300
301 this.control.replay();
302
303 boolean value = this.getStatement().getBoolean(1);
304
305 this.control.verify();
306
307 assert value;
308 }
309 catch (SQLException e)
310 {
311 assert false : e;
312 }
313 }
314
315
318 public void testGetBooleanString()
319 {
320 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
321 EasyMock.expect(this.balancer.first()).andReturn(this.database);
322
323 try
324 {
325 EasyMock.expect(this.getSQLStatement().getBoolean("column")).andReturn(true);
326
327 this.control.replay();
328
329 boolean value = this.getStatement().getBoolean("column");
330
331 this.control.verify();
332
333 assert value;
334 }
335 catch (SQLException e)
336 {
337 assert false : e;
338 }
339 }
340
341
344 public void testGetByteInt()
345 {
346 byte b = 1;
347
348 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
349 EasyMock.expect(this.balancer.first()).andReturn(this.database);
350
351 try
352 {
353 EasyMock.expect(this.getSQLStatement().getByte(1)).andReturn(b);
354
355 this.control.replay();
356
357 byte value = this.getStatement().getByte(1);
358
359 this.control.verify();
360
361 assert value == b;
362 }
363 catch (SQLException e)
364 {
365 assert false : e;
366 }
367 }
368
369
372 public void testGetByteString()
373 {
374 byte b = 1;
375
376 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
377 EasyMock.expect(this.balancer.first()).andReturn(this.database);
378
379 try
380 {
381 EasyMock.expect(this.getSQLStatement().getByte("column")).andReturn(b);
382
383 this.control.replay();
384
385 byte value = this.getStatement().getByte("column");
386
387 this.control.verify();
388
389 assert value == b;
390 }
391 catch (SQLException e)
392 {
393 assert false : e;
394 }
395 }
396
397
400 public void testGetBytesInt()
401 {
402 byte[] bytes = new byte[] { 1 };
403
404 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
405 EasyMock.expect(this.balancer.first()).andReturn(this.database);
406
407 try
408 {
409 EasyMock.expect(this.getSQLStatement().getBytes(1)).andReturn(bytes);
410
411 this.control.replay();
412
413 byte[] value = this.getStatement().getBytes(1);
414
415 this.control.verify();
416
417 assert value == bytes;
418 }
419 catch (SQLException e)
420 {
421 assert false : e;
422 }
423 }
424
425
428 public void testGetBytesString()
429 {
430 byte[] bytes = new byte[] { 1 };
431
432 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
433 EasyMock.expect(this.balancer.first()).andReturn(this.database);
434
435 try
436 {
437 EasyMock.expect(this.getSQLStatement().getBytes("column")).andReturn(bytes);
438
439 this.control.replay();
440
441 byte[] value = this.getStatement().getBytes("column");
442
443 this.control.verify();
444
445 assert value == bytes;
446 }
447 catch (SQLException e)
448 {
449 assert false : e;
450 }
451 }
452
453
456 public void testGetClobInt()
457 {
458 Clob clob = EasyMock.createMock(Clob .class);
459
460 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
461 EasyMock.expect(this.balancer.first()).andReturn(this.database);
462
463 try
464 {
465 EasyMock.expect(this.getSQLStatement().getClob(1)).andReturn(clob);
466
467 this.control.replay();
468
469 Clob value = this.getStatement().getClob(1);
470
471 this.control.verify();
472
473 assert value == clob;
474 }
475 catch (SQLException e)
476 {
477 assert false : e;
478 }
479 }
480
481
484 public void testGetClobString()
485 {
486 Clob clob = EasyMock.createMock(Clob .class);
487
488 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
489 EasyMock.expect(this.balancer.first()).andReturn(this.database);
490
491 try
492 {
493 EasyMock.expect(this.getSQLStatement().getClob("column")).andReturn(clob);
494
495 this.control.replay();
496
497 Clob value = this.getStatement().getClob("column");
498
499 this.control.verify();
500
501 assert value == clob;
502 }
503 catch (SQLException e)
504 {
505 assert false : e;
506 }
507 }
508
509
512 public void testGetDateInt()
513 {
514 Date date = new Date (System.currentTimeMillis());
515
516 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
517 EasyMock.expect(this.balancer.first()).andReturn(this.database);
518
519 try
520 {
521 EasyMock.expect(this.getSQLStatement().getDate(1)).andReturn(date);
522
523 this.control.replay();
524
525 Date value = this.getStatement().getDate(1);
526
527 this.control.verify();
528
529 assert value == date;
530 }
531 catch (SQLException e)
532 {
533 assert false : e;
534 }
535 }
536
537
540 public void testGetDateIntCalendar()
541 {
542 Date date = new Date (System.currentTimeMillis());
543 Calendar calendar = Calendar.getInstance();
544
545 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
546 EasyMock.expect(this.balancer.first()).andReturn(this.database);
547
548 try
549 {
550 EasyMock.expect(this.getSQLStatement().getDate(1, calendar)).andReturn(date);
551
552 this.control.replay();
553
554 Date value = this.getStatement().getDate(1, calendar);
555
556 this.control.verify();
557
558 assert value == date;
559 }
560 catch (SQLException e)
561 {
562 assert false : e;
563 }
564 }
565
566
569 public void testGetDateString()
570 {
571 Date date = new Date (System.currentTimeMillis());
572
573 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
574 EasyMock.expect(this.balancer.first()).andReturn(this.database);
575
576 try
577 {
578 EasyMock.expect(this.getSQLStatement().getDate("column")).andReturn(date);
579
580 this.control.replay();
581
582 Date value = this.getStatement().getDate("column");
583
584 this.control.verify();
585
586 assert value == date;
587 }
588 catch (SQLException e)
589 {
590 assert false : e;
591 }
592 }
593
594
597 public void testGetDateStringCalendar()
598 {
599 Date date = new Date (System.currentTimeMillis());
600 Calendar calendar = Calendar.getInstance();
601
602 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
603 EasyMock.expect(this.balancer.first()).andReturn(this.database);
604
605 try
606 {
607 EasyMock.expect(this.getSQLStatement().getDate("column", calendar)).andReturn(date);
608
609 this.control.replay();
610
611 Date value = this.getStatement().getDate("column", calendar);
612
613 this.control.verify();
614
615 assert value == date;
616 }
617 catch (SQLException e)
618 {
619 assert false : e;
620 }
621 }
622
623
626 public void testGetDoubleInt()
627 {
628 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
629 EasyMock.expect(this.balancer.first()).andReturn(this.database);
630
631 try
632 {
633 EasyMock.expect(this.getSQLStatement().getDouble(1)).andReturn(1.1);
634
635 this.control.replay();
636
637 double value = this.getStatement().getDouble(1);
638
639 this.control.verify();
640
641 assert value == 1.1;
642 }
643 catch (SQLException e)
644 {
645 assert false : e;
646 }
647 }
648
649
652 public void testGetDoubleString()
653 {
654 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
655 EasyMock.expect(this.balancer.first()).andReturn(this.database);
656
657 try
658 {
659 EasyMock.expect(this.getSQLStatement().getDouble("column")).andReturn(1.1);
660
661 this.control.replay();
662
663 double value = this.getStatement().getDouble("column");
664
665 this.control.verify();
666
667 assert value == 1.1;
668 }
669 catch (SQLException e)
670 {
671 assert false : e;
672 }
673 }
674
675
678 public void testGetFloatInt()
679 {
680 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
681 EasyMock.expect(this.balancer.first()).andReturn(this.database);
682
683 try
684 {
685 EasyMock.expect(this.getSQLStatement().getFloat(1)).andReturn(1.1f);
686
687 this.control.replay();
688
689 float value = this.getStatement().getFloat(1);
690
691 this.control.verify();
692
693 assert value == 1.1f;
694 }
695 catch (SQLException e)
696 {
697 assert false : e;
698 }
699 }
700
701
704 public void testGetFloatString()
705 {
706 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
707 EasyMock.expect(this.balancer.first()).andReturn(this.database);
708
709 try
710 {
711 EasyMock.expect(this.getSQLStatement().getFloat("column")).andReturn(1.1f);
712
713 this.control.replay();
714
715 float value = this.getStatement().getFloat("column");
716
717 this.control.verify();
718
719 assert value == 1.1f;
720 }
721 catch (SQLException e)
722 {
723 assert false : e;
724 }
725 }
726
727
730 public void testGetIntInt()
731 {
732 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
733 EasyMock.expect(this.balancer.first()).andReturn(this.database);
734
735 try
736 {
737 EasyMock.expect(this.getSQLStatement().getInt(1)).andReturn(10);
738
739 this.control.replay();
740
741 int value = this.getStatement().getInt(1);
742
743 this.control.verify();
744
745 assert value == 10;
746 }
747 catch (SQLException e)
748 {
749 assert false : e;
750 }
751 }
752
753
756 public void testGetIntString()
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.getSQLStatement().getInt("column")).andReturn(10);
764
765 this.control.replay();
766
767 int value = this.getStatement().getInt("column");
768
769 this.control.verify();
770
771 assert value == 10;
772 }
773 catch (SQLException e)
774 {
775 assert false : e;
776 }
777 }
778
779
782 public void testGetLongInt()
783 {
784 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
785 EasyMock.expect(this.balancer.first()).andReturn(this.database);
786
787 try
788 {
789 EasyMock.expect(this.getSQLStatement().getLong(1)).andReturn(10L);
790
791 this.control.replay();
792
793 long value = this.getStatement().getLong(1);
794
795 this.control.verify();
796
797 assert value == 10L;
798 }
799 catch (SQLException e)
800 {
801 assert false : e;
802 }
803 }
804
805
808 public void testGetLongString()
809 {
810 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
811 EasyMock.expect(this.balancer.first()).andReturn(this.database);
812
813 try
814 {
815 EasyMock.expect(this.getSQLStatement().getLong("column")).andReturn(10L);
816
817 this.control.replay();
818
819 long value = this.getStatement().getLong("column");
820
821 this.control.verify();
822
823 assert value == 10L;
824 }
825 catch (SQLException e)
826 {
827 assert false : e;
828 }
829 }
830
831
834 public void testGetObjectInt()
835 {
836 Object object = new Object ();
837
838 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
839 EasyMock.expect(this.balancer.first()).andReturn(this.database);
840
841 try
842 {
843 EasyMock.expect(this.getSQLStatement().getObject(1)).andReturn(object);
844
845 this.control.replay();
846
847 Object value = this.getStatement().getObject(1);
848
849 this.control.verify();
850
851 assert value == object;
852 }
853 catch (SQLException e)
854 {
855 assert false : e;
856 }
857 }
858
859
862 public void testGetObjectIntMap()
863 {
864 Object object = new Object ();
865 Map typeMap = Collections.EMPTY_MAP;
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.getSQLStatement().getObject(1, typeMap)).andReturn(object);
873
874 this.control.replay();
875
876 Object value = this.getStatement().getObject(1, typeMap);
877
878 this.control.verify();
879
880 assert value == object;
881 }
882 catch (SQLException e)
883 {
884 assert false : e;
885 }
886 }
887
888
891 public void testGetObjectString()
892 {
893 Object object = new Object ();
894
895 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
896 EasyMock.expect(this.balancer.first()).andReturn(this.database);
897
898 try
899 {
900 EasyMock.expect(this.getSQLStatement().getObject("column")).andReturn(object);
901
902 this.control.replay();
903
904 Object value = this.getStatement().getObject("column");
905
906 this.control.verify();
907
908 assert value == object;
909 }
910 catch (SQLException e)
911 {
912 assert false : e;
913 }
914 }
915
916
919 public void testGetObjectStringMap()
920 {
921 Object object = new Object ();
922 Map typeMap = Collections.EMPTY_MAP;
923
924 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
925 EasyMock.expect(this.balancer.first()).andReturn(this.database);
926
927 try
928 {
929 EasyMock.expect(this.getSQLStatement().getObject("column", typeMap)).andReturn(object);
930
931 this.control.replay();
932
933 Object value = this.getStatement().getObject("column", typeMap);
934
935 this.control.verify();
936
937 assert value == object;
938 }
939 catch (SQLException e)
940 {
941 assert false : e;
942 }
943 }
944
945
948 public void testGetRefInt()
949 {
950 Ref ref = EasyMock.createMock(Ref .class);
951
952 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
953 EasyMock.expect(this.balancer.first()).andReturn(this.database);
954
955 try
956 {
957 EasyMock.expect(this.getSQLStatement().getRef(1)).andReturn(ref);
958
959 this.control.replay();
960
961 Ref value = this.getStatement().getRef(1);
962
963 this.control.verify();
964
965 assert value == ref;
966 }
967 catch (SQLException e)
968 {
969 assert false : e;
970 }
971 }
972
973
976 public void testGetRefString()
977 {
978 Ref ref = EasyMock.createMock(Ref .class);
979
980 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
981 EasyMock.expect(this.balancer.first()).andReturn(this.database);
982
983 try
984 {
985 EasyMock.expect(this.getSQLStatement().getRef("column")).andReturn(ref);
986
987 this.control.replay();
988
989 Ref value = this.getStatement().getRef("column");
990
991 this.control.verify();
992
993 assert value == ref;
994 }
995 catch (SQLException e)
996 {
997 assert false : e;
998 }
999 }
1000
1001
1004 public void testGetShortInt()
1005 {
1006 short s = Integer.valueOf(1).shortValue();
1007
1008 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1009 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1010
1011 try
1012 {
1013 EasyMock.expect(this.getSQLStatement().getShort(1)).andReturn(s);
1014
1015 this.control.replay();
1016
1017 short value = this.getStatement().getShort(1);
1018
1019 this.control.verify();
1020
1021 assert value == s;
1022 }
1023 catch (SQLException e)
1024 {
1025 assert false : e;
1026 }
1027 }
1028
1029
1032 public void testGetShortString()
1033 {
1034 short s = Integer.valueOf(1).shortValue();
1035
1036 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1037 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1038
1039 try
1040 {
1041 EasyMock.expect(this.getSQLStatement().getShort("column")).andReturn(s);
1042
1043 this.control.replay();
1044
1045 short value = this.getStatement().getShort("column");
1046
1047 this.control.verify();
1048
1049 assert value == s;
1050 }
1051 catch (SQLException e)
1052 {
1053 assert false : e;
1054 }
1055 }
1056
1057
1060 public void testGetStringInt()
1061 {
1062 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1063 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1064
1065 try
1066 {
1067 EasyMock.expect(this.getSQLStatement().getString(1)).andReturn("test");
1068
1069 this.control.replay();
1070
1071 String value = this.getStatement().getString(1);
1072
1073 this.control.verify();
1074
1075 assert value == "test";
1076 }
1077 catch (SQLException e)
1078 {
1079 assert false : e;
1080 }
1081 }
1082
1083
1086 public void testGetStringString()
1087 {
1088 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1089 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1090
1091 try
1092 {
1093 EasyMock.expect(this.getSQLStatement().getString("column")).andReturn("test");
1094
1095 this.control.replay();
1096
1097 String value = this.getStatement().getString("column");
1098
1099 this.control.verify();
1100
1101 assert value == "test";
1102 }
1103 catch (SQLException e)
1104 {
1105 assert false : e;
1106 }
1107 }
1108
1109
1112 public void testGetTimeInt()
1113 {
1114 Time time = new Time (System.currentTimeMillis());
1115
1116 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1117 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1118
1119 try
1120 {
1121 EasyMock.expect(this.getSQLStatement().getTime(1)).andReturn(time);
1122
1123 this.control.replay();
1124
1125 Time value = this.getStatement().getTime(1);
1126
1127 this.control.verify();
1128
1129 assert value == time;
1130 }
1131 catch (SQLException e)
1132 {
1133 assert false : e;
1134 }
1135 }
1136
1137
1140 public void testGetTimeIntCalendar()
1141 {
1142 Time time = new Time (System.currentTimeMillis());
1143 Calendar calendar = Calendar.getInstance();
1144
1145 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1146 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1147
1148 try
1149 {
1150 EasyMock.expect(this.getSQLStatement().getTime(1, calendar)).andReturn(time);
1151
1152 this.control.replay();
1153
1154 Time value = this.getStatement().getTime(1, calendar);
1155
1156 this.control.verify();
1157
1158 assert value == time;
1159 }
1160 catch (SQLException e)
1161 {
1162 assert false : e;
1163 }
1164 }
1165
1166
1169 public void testGetTimeString()
1170 {
1171 Time time = new Time (System.currentTimeMillis());
1172
1173 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1174 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1175
1176 try
1177 {
1178 EasyMock.expect(this.getSQLStatement().getTime("column")).andReturn(time);
1179
1180 this.control.replay();
1181
1182 Time value = this.getStatement().getTime("column");
1183
1184 this.control.verify();
1185
1186 assert value == time;
1187 }
1188 catch (SQLException e)
1189 {
1190 assert false : e;
1191 }
1192 }
1193
1194
1197 public void testGetTimeStringCalendar()
1198 {
1199 Time time = new Time (System.currentTimeMillis());
1200 Calendar calendar = Calendar.getInstance();
1201
1202 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1203 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1204
1205 try
1206 {
1207 EasyMock.expect(this.getSQLStatement().getTime("column", calendar)).andReturn(time);
1208
1209 this.control.replay();
1210
1211 Time value = this.getStatement().getTime("column", calendar);
1212
1213 this.control.verify();
1214
1215 assert value == time;
1216 }
1217 catch (SQLException e)
1218 {
1219 assert false : e;
1220 }
1221 }
1222
1223
1226 public void testGetTimestampInt()
1227 {
1228 Timestamp timestamp = new Timestamp (System.currentTimeMillis());
1229
1230 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1231 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1232
1233 try
1234 {
1235 EasyMock.expect(this.getSQLStatement().getTimestamp(1)).andReturn(timestamp);
1236
1237 this.control.replay();
1238
1239 Timestamp value = this.getStatement().getTimestamp(1);
1240
1241 this.control.verify();
1242
1243 assert value == timestamp;
1244 }
1245 catch (SQLException e)
1246 {
1247 assert false : e;
1248 }
1249 }
1250
1251
1254 public void testGetTimestampIntCalendar()
1255 {
1256 Timestamp timestamp = new Timestamp (System.currentTimeMillis());
1257 Calendar calendar = Calendar.getInstance();
1258
1259 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1260 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1261
1262 try
1263 {
1264 EasyMock.expect(this.getSQLStatement().getTimestamp(1, calendar)).andReturn(timestamp);
1265
1266 this.control.replay();
1267
1268 Timestamp value = this.getStatement().getTimestamp(1, calendar);
1269
1270 this.control.verify();
1271
1272 assert value == timestamp;
1273 }
1274 catch (SQLException e)
1275 {
1276 assert false : e;
1277 }
1278 }
1279
1280
1283 public void testGetTimestampString()
1284 {
1285 Timestamp timestamp = new Timestamp (System.currentTimeMillis());
1286
1287 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1288 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1289
1290 try
1291 {
1292 EasyMock.expect(this.getSQLStatement().getTimestamp("column")).andReturn(timestamp);
1293
1294 this.control.replay();
1295
1296 Timestamp value = this.getStatement().getTimestamp("column");
1297
1298 this.control.verify();
1299
1300 assert value == timestamp;
1301 }
1302 catch (SQLException e)
1303 {
1304 assert false : e;
1305 }
1306 }
1307
1308
1311 public void testGetTimestampStringCalendar()
1312 {
1313 Timestamp timestamp = new Timestamp (System.currentTimeMillis());
1314 Calendar calendar = Calendar.getInstance();
1315
1316 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1317 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1318
1319 try
1320 {
1321 EasyMock.expect(this.getSQLStatement().getTimestamp("column", calendar)).andReturn(timestamp);
1322
1323 this.control.replay();
1324
1325 Timestamp value = this.getStatement().getTimestamp("column", calendar);
1326
1327 this.control.verify();
1328
1329 assert value == timestamp;
1330 }
1331 catch (SQLException e)
1332 {
1333 assert false : e;
1334 }
1335 }
1336
1337
1340 public void testGetURLInt()
1341 {
1342 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1343 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1344
1345 try
1346 {
1347 URL url = new URL ("http://www.google.com");
1348
1349 EasyMock.expect(this.getSQLStatement().getURL(1)).andReturn(url);
1350
1351 this.control.replay();
1352
1353 URL value = this.getStatement().getURL(1);
1354
1355 this.control.verify();
1356
1357 assert value == url;
1358 }
1359 catch (Exception e)
1360 {
1361 assert false : e;
1362 }
1363 }
1364
1365
1368 public void testGetURLString()
1369 {
1370 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1371 EasyMock.expect(this.balancer.first()).andReturn(this.database);
1372
1373 try
1374 {
1375 URL url = new URL ("http://www.google.com");
1376
1377 EasyMock.expect(this.getSQLStatement().getURL("column")).andReturn(url);
1378
1379 this.control.replay();
1380
1381 URL value = this.getStatement().getURL("column");
1382
1383 this.control.verify();
1384
1385 assert value == url;
1386 }
1387 catch (Exception e)
1388 {
1389 assert false : e;
1390 }
1391 }
1392
1393
1396 public void testRegisterOutParameterIntInt()
1397 {
1398 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1399
1400 this.lock.lock();
1401
1402 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1403 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1404
1405 try
1406 {
1407 this.getSQLStatement().registerOutParameter(1, Types.ARRAY);
1408
1409 this.lock.unlock();
1410
1411 this.control.replay();
1412
1413 this.getStatement().registerOutParameter(1, Types.ARRAY);
1414
1415 this.control.verify();
1416 }
1417 catch (Exception e)
1418 {
1419 assert false : e;
1420 }
1421 }
1422
1423
1426 public void testRegisterOutParameterIntIntInt()
1427 {
1428 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1429
1430 this.lock.lock();
1431
1432 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1433 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1434
1435 try
1436 {
1437 this.getSQLStatement().registerOutParameter(1, Types.NUMERIC, 10);
1438
1439 this.lock.unlock();
1440
1441 this.control.replay();
1442
1443 this.getStatement().registerOutParameter(1, Types.NUMERIC, 10);
1444
1445 this.control.verify();
1446 }
1447 catch (Exception e)
1448 {
1449 assert false : e;
1450 }
1451 }
1452
1453
1456 public void testRegisterOutParameterIntIntString()
1457 {
1458 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1459
1460 this.lock.lock();
1461
1462 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1463 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1464
1465 try
1466 {
1467 this.getSQLStatement().registerOutParameter(1, Types.JAVA_OBJECT, "test");
1468
1469 this.lock.unlock();
1470
1471 this.control.replay();
1472
1473 this.getStatement().registerOutParameter(1, Types.JAVA_OBJECT, "test");
1474
1475 this.control.verify();
1476 }
1477 catch (Exception e)
1478 {
1479 assert false : e;
1480 }
1481 }
1482
1483
1486 public void testRegisterOutParameterStringInt()
1487 {
1488 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1489
1490 this.lock.lock();
1491
1492 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1493 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1494
1495 try
1496 {
1497 this.getSQLStatement().registerOutParameter("param", Types.ARRAY);
1498
1499 this.lock.unlock();
1500
1501 this.control.replay();
1502
1503 this.getStatement().registerOutParameter("param", Types.ARRAY);
1504
1505 this.control.verify();
1506 }
1507 catch (Exception e)
1508 {
1509 assert false : e;
1510 }
1511 }
1512
1513
1516 public void testRegisterOutParameterStringIntInt()
1517 {
1518 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1519
1520 this.lock.lock();
1521
1522 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1523 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1524
1525 try
1526 {
1527 this.getSQLStatement().registerOutParameter("param", Types.NUMERIC, 10);
1528
1529 this.lock.unlock();
1530
1531 this.control.replay();
1532
1533 this.getStatement().registerOutParameter("param", Types.NUMERIC, 10);
1534
1535 this.control.verify();
1536 }
1537 catch (Exception e)
1538 {
1539 assert false : e;
1540 }
1541 }
1542
1543
1546 public void testRegisterOutParameterStringIntString()
1547 {
1548 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1549
1550 this.lock.lock();
1551
1552 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1553 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1554
1555 try
1556 {
1557 this.getSQLStatement().registerOutParameter("param", Types.JAVA_OBJECT, "test");
1558
1559 this.lock.unlock();
1560
1561 this.control.replay();
1562
1563 this.getStatement().registerOutParameter("param", Types.JAVA_OBJECT, "test");
1564
1565 this.control.verify();
1566 }
1567 catch (Exception e)
1568 {
1569 assert false : e;
1570 }
1571 }
1572
1573
1576 public void testSetAsciiStreamStringInputStreamInt()
1577 {
1578 InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 });
1579 File file = new File ("");
1580
1581 try
1582 {
1583 EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
1584
1585 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1586
1587 this.lock.lock();
1588
1589 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1590 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1591
1592 EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
1593
1594 this.getSQLStatement().setAsciiStream("param", inputStream, 100);
1595
1596 this.lock.unlock();
1597
1598 this.control.replay();
1599
1600 this.getStatement().setAsciiStream("param", inputStream, 100);
1601
1602 this.control.verify();
1603 }
1604 catch (Exception e)
1605 {
1606 assert false : e;
1607 }
1608 }
1609
1610
1613 public void testSetBigDecimalStringBigDecimal()
1614 {
1615 BigDecimal decimal = new BigDecimal (1.1);
1616
1617 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1618
1619 this.lock.lock();
1620
1621 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1622 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1623
1624 try
1625 {
1626 this.getSQLStatement().setBigDecimal("param", decimal);
1627
1628 this.lock.unlock();
1629
1630 this.control.replay();
1631
1632 this.getStatement().setBigDecimal("param", decimal);
1633
1634 this.control.verify();
1635 }
1636 catch (Exception e)
1637 {
1638 assert false : e;
1639 }
1640 }
1641
1642
1645 public void testSetBinaryStreamStringInputStreamInt()
1646 {
1647 InputStream inputStream = new ByteArrayInputStream (new byte[] { 1 });
1648 File file = new File ("");
1649
1650 try
1651 {
1652 EasyMock.expect(this.fileSupport.createFile(inputStream)).andReturn(file);
1653
1654 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1655
1656 this.lock.lock();
1657
1658 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1659 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1660
1661 EasyMock.expect(this.fileSupport.getInputStream(file)).andReturn(inputStream);
1662
1663 this.getSQLStatement().setBinaryStream("param", inputStream, 100);
1664
1665 this.lock.unlock();
1666
1667 this.control.replay();
1668
1669 this.getStatement().setBinaryStream("param", inputStream, 100);
1670
1671 this.control.verify();
1672 }
1673 catch (Exception e)
1674 {
1675 assert false : e;
1676 }
1677 }
1678
1679
1682 public void testSetBooleanStringBoolean()
1683 {
1684 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1685
1686 this.lock.lock();
1687
1688 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1689 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1690
1691 try
1692 {
1693 this.getSQLStatement().setBoolean("param", true);
1694
1695 this.lock.unlock();
1696
1697 this.control.replay();
1698
1699 this.getStatement().setBoolean("param", true);
1700
1701 this.control.verify();
1702 }
1703 catch (Exception e)
1704 {
1705 assert false : e;
1706 }
1707 }
1708
1709
1712 public void testSetByteStringByte()
1713 {
1714 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1715
1716 this.lock.lock();
1717
1718 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1719 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1720
1721 try
1722 {
1723 this.getSQLStatement().setByte("param", (byte) 1);
1724
1725 this.lock.unlock();
1726
1727 this.control.replay();
1728
1729 this.getStatement().setByte("param", (byte) 1);
1730
1731 this.control.verify();
1732 }
1733 catch (Exception e)
1734 {
1735 assert false : e;
1736 }
1737 }
1738
1739
1742 public void testSetBytesStringByteArray()
1743 {
1744 byte[] bytes = new byte[] { 1 };
1745
1746 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1747
1748 this.lock.lock();
1749
1750 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1751 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1752
1753 try
1754 {
1755 this.getSQLStatement().setBytes("param", bytes);
1756
1757 this.lock.unlock();
1758
1759 this.control.replay();
1760
1761 this.getStatement().setBytes("param", bytes);
1762
1763 this.control.verify();
1764 }
1765 catch (Exception e)
1766 {
1767 assert false : e;
1768 }
1769 }
1770
1771
1774 public void testSetCharacterStreamStringReaderInt()
1775 {
1776 Reader reader = new StringReader ("test");
1777 File file = new File ("");
1778
1779 try
1780 {
1781 EasyMock.expect(this.fileSupport.createFile(reader)).andReturn(file);
1782
1783 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1784
1785 this.lock.lock();
1786
1787 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1788 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1789
1790 EasyMock.expect(this.fileSupport.getReader(file)).andReturn(reader);
1791
1792 this.getSQLStatement().setCharacterStream("param", reader, 100);
1793
1794 this.lock.unlock();
1795
1796 this.control.replay();
1797
1798 this.getStatement().setCharacterStream("param", reader, 100);
1799
1800 this.control.verify();
1801 }
1802 catch (Exception e)
1803 {
1804 assert false : e;
1805 }
1806 }
1807
1808
1811 public void testSetDateStringDate()
1812 {
1813 Date date = new Date (System.currentTimeMillis());
1814
1815 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1816
1817 this.lock.lock();
1818
1819 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1820 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1821
1822 try
1823 {
1824 this.getSQLStatement().setDate("param", date);
1825
1826 this.lock.unlock();
1827
1828 this.control.replay();
1829
1830 this.getStatement().setDate("param", date);
1831
1832 this.control.verify();
1833 }
1834 catch (Exception e)
1835 {
1836 assert false : e;
1837 }
1838 }
1839
1840
1843 public void testSetDateStringDateCalendar()
1844 {
1845 Date date = new Date (System.currentTimeMillis());
1846 Calendar calendar = Calendar.getInstance();
1847
1848 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1849
1850 this.lock.lock();
1851
1852 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1853 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1854
1855 try
1856 {
1857 this.getSQLStatement().setDate("param", date, calendar);
1858
1859 this.lock.unlock();
1860
1861 this.control.replay();
1862
1863 this.getStatement().setDate("param", date, calendar);
1864
1865 this.control.verify();
1866 }
1867 catch (Exception e)
1868 {
1869 assert false : e;
1870 }
1871 }
1872
1873
1876 public void testSetDoubleStringDouble()
1877 {
1878 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1879
1880 this.lock.lock();
1881
1882 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1883 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1884
1885 try
1886 {
1887 this.getSQLStatement().setDouble("param", 1.1);
1888
1889 this.lock.unlock();
1890
1891 this.control.replay();
1892
1893 this.getStatement().setDouble("param", 1.1);
1894
1895 this.control.verify();
1896 }
1897 catch (Exception e)
1898 {
1899 assert false : e;
1900 }
1901 }
1902
1903
1906 public void testSetFloatStringFloat()
1907 {
1908 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1909
1910 this.lock.lock();
1911
1912 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1913 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1914
1915 try
1916 {
1917 this.getSQLStatement().setFloat("param", 1.1f);
1918
1919 this.lock.unlock();
1920
1921 this.control.replay();
1922
1923 this.getStatement().setFloat("param", 1.1f);
1924
1925 this.control.verify();
1926 }
1927 catch (Exception e)
1928 {
1929 assert false : e;
1930 }
1931 }
1932
1933
1936 public void testSetIntStringInt()
1937 {
1938 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1939
1940 this.lock.lock();
1941
1942 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1943 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1944
1945 try
1946 {
1947 this.getSQLStatement().setInt("param", 10);
1948
1949 this.lock.unlock();
1950
1951 this.control.replay();
1952
1953 this.getStatement().setInt("param", 10);
1954
1955 this.control.verify();
1956 }
1957 catch (Exception e)
1958 {
1959 assert false : e;
1960 }
1961 }
1962
1963
1966 public void testSetLongStringLong()
1967 {
1968 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1969
1970 this.lock.lock();
1971
1972 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
1973 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
1974
1975 try
1976 {
1977 this.getSQLStatement().setLong("param", 10);
1978
1979 this.lock.unlock();
1980
1981 this.control.replay();
1982
1983 this.getStatement().setLong("param", 10);
1984
1985 this.control.verify();
1986 }
1987 catch (Exception e)
1988 {
1989 assert false : e;
1990 }
1991 }
1992
1993
1996 public void testSetNullStringInt()
1997 {
1998 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
1999
2000 this.lock.lock();
2001
2002 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2003 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2004
2005 try
2006 {
2007 this.getSQLStatement().setNull("param", Types.ARRAY);
2008
2009 this.lock.unlock();
2010
2011 this.control.replay();
2012
2013 this.getStatement().setNull("param", Types.ARRAY);
2014
2015 this.control.verify();
2016 }
2017 catch (Exception e)
2018 {
2019 assert false : e;
2020 }
2021 }
2022
2023
2026 public void testSetNullStringIntString()
2027 {
2028 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2029
2030 this.lock.lock();
2031
2032 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2033 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2034
2035 try
2036 {
2037 this.getSQLStatement().setNull("param", Types.JAVA_OBJECT, "test");
2038
2039 this.lock.unlock();
2040
2041 this.control.replay();
2042
2043 this.getStatement().setNull("param", Types.JAVA_OBJECT, "test");
2044
2045 this.control.verify();
2046 }
2047 catch (Exception e)
2048 {
2049 assert false : e;
2050 }
2051 }
2052
2053
2056 public void testSetObjectStringObject()
2057 {
2058 Object object = new Object ();
2059
2060 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2061
2062 this.lock.lock();
2063
2064 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2065 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2066
2067 try
2068 {
2069 this.getSQLStatement().setObject("param", object);
2070
2071 this.lock.unlock();
2072
2073 this.control.replay();
2074
2075 this.getStatement().setObject("param", object);
2076
2077 this.control.verify();
2078 }
2079 catch (Exception e)
2080 {
2081 assert false : e;
2082 }
2083 }
2084
2085
2088 public void testSetObjectStringObjectInt()
2089 {
2090 Object object = new Object ();
2091
2092 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2093
2094 this.lock.lock();
2095
2096 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2097 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2098
2099 try
2100 {
2101 this.getSQLStatement().setObject("param", object, Types.ARRAY);
2102
2103 this.lock.unlock();
2104
2105 this.control.replay();
2106
2107 this.getStatement().setObject("param", object, Types.ARRAY);
2108
2109 this.control.verify();
2110 }
2111 catch (Exception e)
2112 {
2113 assert false : e;
2114 }
2115 }
2116
2117
2120 public void testSetObjectStringObjectIntInt()
2121 {
2122 Object object = new Object ();
2123
2124 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2125
2126 this.lock.lock();
2127
2128 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2129 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2130
2131 try
2132 {
2133 this.getSQLStatement().setObject("param", object, Types.NUMERIC, 10);
2134
2135 this.lock.unlock();
2136
2137 this.control.replay();
2138
2139 this.getStatement().setObject("param", object, Types.NUMERIC, 10);
2140
2141 this.control.verify();
2142 }
2143 catch (Exception e)
2144 {
2145 assert false : e;
2146 }
2147 }
2148
2149
2152 public void testSetShortStringShort()
2153 {
2154 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2155
2156 this.lock.lock();
2157
2158 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2159 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2160
2161 try
2162 {
2163 this.getSQLStatement().setShort("param", (short) 10);
2164
2165 this.lock.unlock();
2166
2167 this.control.replay();
2168
2169 this.getStatement().setShort("param", (short) 10);
2170
2171 this.control.verify();
2172 }
2173 catch (Exception e)
2174 {
2175 assert false : e;
2176 }
2177 }
2178
2179
2182 public void testSetStringStringString()
2183 {
2184 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2185
2186 this.lock.lock();
2187
2188 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2189 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2190
2191 try
2192 {
2193 this.getSQLStatement().setString("param", "test");
2194
2195 this.lock.unlock();
2196
2197 this.control.replay();
2198
2199 this.getStatement().setString("param", "test");
2200
2201 this.control.verify();
2202 }
2203 catch (Exception e)
2204 {
2205 assert false : e;
2206 }
2207 }
2208
2209
2212 public void testSetTimeStringTime()
2213 {
2214 Time time = new Time (System.currentTimeMillis());
2215
2216 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2217
2218 this.lock.lock();
2219
2220 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2221 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2222
2223 try
2224 {
2225 this.getSQLStatement().setTime("param", time);
2226
2227 this.lock.unlock();
2228
2229 this.control.replay();
2230
2231 this.getStatement().setTime("param", time);
2232
2233 this.control.verify();
2234 }
2235 catch (Exception e)
2236 {
2237 assert false : e;
2238 }
2239 }
2240
2241
2244 public void testSetTimeStringTimeCalendar()
2245 {
2246 Time time = new Time (System.currentTimeMillis());
2247 Calendar calendar = Calendar.getInstance();
2248
2249 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2250
2251 this.lock.lock();
2252
2253 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2254 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2255
2256 try
2257 {
2258 this.getSQLStatement().setTime("param", time, calendar);
2259
2260 this.lock.unlock();
2261
2262 this.control.replay();
2263
2264 this.getStatement().setTime("param", time, calendar);
2265
2266 this.control.verify();
2267 }
2268 catch (Exception e)
2269 {
2270 assert false : e;
2271 }
2272 }
2273
2274
2277 public void testSetTimestampStringTimestamp()
2278 {
2279 Timestamp timestamp = new Timestamp (System.currentTimeMillis());
2280
2281 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2282
2283 this.lock.lock();
2284
2285 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2286 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2287
2288 try
2289 {
2290 this.getSQLStatement().setTimestamp("param", timestamp);
2291
2292 this.lock.unlock();
2293
2294 this.control.replay();
2295
2296 this.getStatement().setTimestamp("param", timestamp);
2297
2298 this.control.verify();
2299 }
2300 catch (Exception e)
2301 {
2302 assert false : e;
2303 }
2304 }
2305
2306
2309 public void testSetTimestampStringTimestampCalendar()
2310 {
2311 Timestamp timestamp = new Timestamp (System.currentTimeMillis());
2312 Calendar calendar = Calendar.getInstance();
2313
2314 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2315
2316 this.lock.lock();
2317
2318 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2319 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2320
2321 try
2322 {
2323 this.getSQLStatement().setTimestamp("param", timestamp, calendar);
2324
2325 this.lock.unlock();
2326
2327 this.control.replay();
2328
2329 this.getStatement().setTimestamp("param", timestamp, calendar);
2330
2331 this.control.verify();
2332 }
2333 catch (Exception e)
2334 {
2335 assert false : e;
2336 }
2337 }
2338
2339
2342 public void testSetURLStringURL()
2343 {
2344 EasyMock.expect(this.databaseCluster.readLock()).andReturn(this.lock);
2345
2346 this.lock.lock();
2347
2348 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2349 EasyMock.expect(this.balancer.list()).andReturn(this.databaseList);
2350
2351 try
2352 {
2353 URL url = new URL ("http://www.google.com");
2354
2355 this.getSQLStatement().setURL("param", url);
2356
2357 this.lock.unlock();
2358
2359 this.control.replay();
2360
2361 this.getStatement().setURL("param", url);
2362
2363 this.control.verify();
2364 }
2365 catch (Exception e)
2366 {
2367 assert false : e;
2368 }
2369 }
2370
2371
2374 public void testWasNull()
2375 {
2376 EasyMock.expect(this.databaseCluster.getBalancer()).andReturn(this.balancer);
2377 EasyMock.expect(this.balancer.first()).andReturn(this.database);
2378
2379 try
2380 {
2381 EasyMock.expect(this.getSQLStatement().wasNull()).andReturn(true);
2382
2383 this.control.replay();
2384
2385 boolean wasNull = this.getStatement().wasNull();
2386
2387 this.control.verify();
2388
2389 assert wasNull;
2390 }
2391 catch (Exception e)
2392 {
2393 assert false : e;
2394 }
2395 }
2396}
2397 |
Popular Tags |
Java API By Example, From Geeks To Geeks.