|
1
22 package org.jboss.test.cmp2.simple;
23
24 import java.math.BigDecimal  ;
25 import java.sql.Time ;
26 import java.sql.Timestamp ;
27 import java.util.Collection ;
28 import java.util.Calendar ;
29 import java.util.HashMap ;
30 import java.util.Hashtable ;
31 import java.util.Properties ;
32 import javax.naming.InitialContext ;
33 import javax.ejb.DuplicateKeyException ;
34
35 import org.jboss.logging.Logger;
36
37 import junit.framework.Test;
38 import org.jboss.test.JBossTestCase;
39 import org.jboss.test.util.ejb.EJBTestCase;
40
41
47 public class SimpleUnitTestCase extends EJBTestCase
48 {
49 private static Logger log = Logger.getLogger(SimpleUnitTestCase.class);
50
51 public static Test suite() throws Exception
52 {
53 return JBossTestCase.getDeploySetup(
54 SimpleUnitTestCase.class, "cmp2-simple.jar");
55 }
56
57 public SimpleUnitTestCase(String name)
58 {
59 super(name);
60
61 Calendar c = Calendar.getInstance();
62 c.clear(); c.set(1981, 4, 5);
64 sqlDateValue = new java.sql.Date (c.getTime().getTime());
65
66 c = Calendar.getInstance();
67 c.clear(); c.set(Calendar.HOUR_OF_DAY, 22);
69 c.set(Calendar.MINUTE, 33);
70 c.set(Calendar.SECOND, 44);
71 timeValue = new java.sql.Time (c.getTime().getTime());
73
74 objectValue = new HashMap ();
75 ((HashMap ) objectValue).put("boolean", booleanObject);
76 ((HashMap ) objectValue).put("byte", byteObject);
77 ((HashMap ) objectValue).put("short", shortObject);
78 ((HashMap ) objectValue).put("int", integerObject);
79 ((HashMap ) objectValue).put("long", longObject);
80 ((HashMap ) objectValue).put("float", floatObject);
81 ((HashMap ) objectValue).put("double", doubleObject);
82 ((HashMap ) objectValue).put("string", stringValue);
83 ((HashMap ) objectValue).put("utilDate", utilDateValue);
84 ((HashMap ) objectValue).put("sqlDate", sqlDateValue);
85 ((HashMap ) objectValue).put("time", timeValue);
86 ((HashMap ) objectValue).put("timestamp", timestampValue);
87 ((HashMap ) objectValue).put("bigDecimal", bigDecimalValue);
88 }
89
90 private SimpleHome getSimpleHome()
91 {
92 try
93 {
94 InitialContext jndiContext = new InitialContext ();
95
96 return (SimpleHome) jndiContext.lookup("cmp2/simple/Simple");
97 }
98 catch (Exception e)
99 {
100 log.debug("failed", e);
101 fail("Exception in getSimpleHome: " + e.getMessage());
102 }
103 return null;
104 }
105
106 private Simple simple;
107 private final boolean booleanPrimitive = true;
108 private final Boolean booleanObject = Boolean.FALSE;
109 private final byte bytePrimitive = (byte) 11;
110 private final Byte byteObject = new Byte ((byte) 22);
111 private final short shortPrimitive = (short) 33;
112 private final Short shortObject = new Short ((short) 44);
113 private final int integerPrimitive = 55;
114 private final Integer integerObject = new Integer (66);
115 private final long longPrimitive = 77;
116 private final Long longObject = new Long (88);
117 private final float floatPrimitive = 11.11f;
118 private final Float floatObject = new Float (22.22f);
119 private final double doublePrimitive = 33.33;
120 private final Double doubleObject = new Double (44.44);
121 private final String stringValue = "test string value";
122 private final java.util.Date utilDateValue = new java.util.Date (1111);
123 private final java.sql.Date sqlDateValue;
124 private final Time timeValue;
125 private final Timestamp timestampValue = new Timestamp (4444);
126 private final BigDecimal bigDecimalValue = new BigDecimal ("12345678.1234");
127 private final byte[] byteArrayValue = "byte array test".getBytes();
128 private final Object objectValue;
129 private final ValueClass valueClass = new ValueClass(111, 999);
130 private final Hashtable hashtable = new Hashtable ();
131
132 public void testBooleanPrimitive() throws Exception
133 {
134 assertEquals(booleanPrimitive, simple.getBooleanPrimitive());
135 }
136
137 public void testBooleanObject() throws Exception
138 {
139 assertEquals(booleanObject, simple.getBooleanObject());
140 }
141
142 public void testBytePrimitive() throws Exception
143 {
144 assertEquals(bytePrimitive, simple.getBytePrimitive());
145 }
146
147 public void testByteObject() throws Exception
148 {
149 assertEquals(byteObject, simple.getByteObject());
150 }
151
152 public void testShortPrimitive() throws Exception
153 {
154 assertEquals(shortPrimitive, simple.getShortPrimitive());
155 }
156
157 public void testShortObject() throws Exception
158 {
159 assertEquals(shortObject, simple.getShortObject());
160 }
161
162 public void testIntegerPrimitive() throws Exception
163 {
164 assertEquals(integerPrimitive, simple.getIntegerPrimitive());
165 }
166
167 public void testIntegerObject() throws Exception
168 {
169 assertEquals(integerObject, simple.getIntegerObject());
170 }
171
172 public void testLongPrimitive() throws Exception
173 {
174 assertEquals(longPrimitive, simple.getLongPrimitive());
175 }
176
177 public void testLongObject() throws Exception
178 {
179 assertEquals(longObject, simple.getLongObject());
180 }
181
182 public void testFloatPrimitive() throws Exception
183 {
184 assertEquals(floatPrimitive, simple.getFloatPrimitive(), 0);
185 }
186
187 public void testFloatObject() throws Exception
188 {
189 assertEquals(floatObject, simple.getFloatObject());
190 }
191
192 public void testDoublePrimitive() throws Exception
193 {
194 assertEquals(doublePrimitive, simple.getDoublePrimitive(), 0);
195 }
196
197 public void testDoubleObject() throws Exception
198 {
199 assertEquals(doubleObject, simple.getDoubleObject());
200 }
201
202 public void testStringValue() throws Exception
203 {
204 assertEquals(stringValue, simple.getStringValue());
205 }
206
207 public void testUtilDateValue() throws Exception
208 {
209 assertTrue(
210 "expected :<" + simple.getUtilDateValue() + "> but was <" +
211 utilDateValue + ">",
212 utilDateValue.compareTo(simple.getUtilDateValue()) == 0);
213 }
214
215 public void testSqlDateValue() throws Exception
216 {
217 assertTrue(
218 "expected :<" + simple.getSqlDateValue() + "> but was <" +
219 sqlDateValue + ">",
220 sqlDateValue.compareTo(simple.getSqlDateValue()) == 0);
221 }
222
223 public void testTimeValue() throws Exception
224 {
225 assertTrue(
226 "expected :<" + simple.getTimeValue() + "> but was <" +
227 timeValue + ">",
228 timeValue.compareTo(simple.getTimeValue()) == 0);
229 }
230
231 public void testTimestampValue() throws Exception
232 {
233 assertTrue(
234 "expected :<" + simple.getTimestampValue() + "> but was <" +
235 timestampValue + ">",
236 timestampValue.compareTo(simple.getTimestampValue()) == 0);
237 }
238
239 public void testBigDecimalValue() throws Exception
240 {
241 assertTrue(
242 "expected :<" + simple.getBigDecimalValue() + "> but was <" +
243 bigDecimalValue + ">",
244 bigDecimalValue.compareTo(simple.getBigDecimalValue()) == 0);
245 }
246
247 public void testByteArrayValue() throws Exception
248 {
249 byte[] array = simple.getByteArrayValue();
250 assertEquals(byteArrayValue.length, array.length);
251 for (int i = 0; i < array.length; i++)
252 {
253 assertEquals(byteArrayValue[i], array[i]);
254 }
255 }
256
257 public void testValueClass() throws Exception
258 {
259 ValueClass vc = simple.getValueClass();
260 log.info("getValueClass class: " + vc.getClass().getName());
261 log.info("getValueClass classloader: " + vc.getClass().getClassLoader());
262 log.info("ValueClass class: " + valueClass.getClass().getName());
263 log.info("ValueClass classloader: " + valueClass.getClass().getClassLoader());
264 assertEquals(valueClass, vc);
265 }
266
267 public void testObjectValue() throws Exception
268 {
269 Object v = simple.getObjectValue();
270 log.info("getObjectValue class: " + v.getClass().getName());
271 log.info("getObjectValue classloader: " + v.getClass().getClassLoader());
272 log.info("objectValue class: " + objectValue.getClass().getName());
273 log.info("objectValue classloader: " + objectValue.getClass().getClassLoader());
274 assertEquals(objectValue, v);
275 }
276
277 public void testLiteralToLiteral() throws Exception
278 {
279 SimpleHome simpleHome = getSimpleHome();
280 Collection c;
281
282 c = simpleHome.selectDynamic(
283 "SELECT OBJECT(s) " +
284 "FROM simple s " +
285 "WHERE TRUE=TRUE",
286 new Object [0]);
287 assertTrue(c.size() == 1);
288
289 c = simpleHome.selectDynamic(
290 "SELECT OBJECT(s) " +
291 "FROM simple s " +
292 "WHERE 1.2=1.2",
293 new Object [0]);
294 assertTrue(c.size() == 1);
295
296 c = simpleHome.selectDynamic(
297 "SELECT OBJECT(s) " +
298 "FROM simple s " +
299 "WHERE 'funk'='funk'",
300 new Object [0]);
301 assertTrue(c.size() == 1);
302 }
303
304 public void testUtilDateBetween() throws Exception
305 {
306 SimpleHome simpleHome = getSimpleHome();
307 Collection c;
308
309 java.util.Date utilDateBefore = new java.util.Date (100);
310 java.util.Date utilDateAfter = new java.util.Date (2000);
311 c = simpleHome.selectDynamic(
312 "SELECT OBJECT(s) " +
313 "FROM simple s " +
314 "WHERE s.utilDateValue BETWEEN ?1 AND ?2",
315 new Object []{utilDateBefore, utilDateAfter});
316 assertTrue(c.size() == 1);
317 }
318
319 public void testSQLDateBetween() throws Exception
320 {
321 SimpleHome simpleHome = getSimpleHome();
322 Collection c;
323 Calendar calendar;
324
325 calendar = Calendar.getInstance();
326 calendar.clear(); calendar.set(1981, 4, 3);
328 java.sql.Date sqlDateBefore =
329 new java.sql.Date (calendar.getTime().getTime());
330
331 calendar = Calendar.getInstance();
332 calendar.clear(); calendar.set(1981, 4, 6);
334 java.sql.Date sqlDateAfter =
335 new java.sql.Date (calendar.getTime().getTime());
336
337 c = simpleHome.selectDynamic(
338 "SELECT OBJECT(s) " +
339 "FROM simple s " +
340 "WHERE s.sqlDateValue BETWEEN ?1 AND ?2",
341 new Object []{sqlDateBefore, sqlDateAfter});
342 assertTrue(c.size() == 1);
343 }
344
345 public void testTimeBetween() throws Exception
346 {
347 SimpleHome simpleHome = getSimpleHome();
348 Collection c;
349 Calendar calendar;
350
351 calendar = Calendar.getInstance();
352 calendar.clear(); calendar.set(Calendar.HOUR_OF_DAY, 21);
354 calendar.set(Calendar.MINUTE, 33);
355 calendar.set(Calendar.SECOND, 44);
356 Time timeBefore = new java.sql.Time (calendar.getTime().getTime());
358
359 calendar = Calendar.getInstance();
360 calendar.clear(); calendar.set(Calendar.HOUR_OF_DAY, 23);
362 calendar.set(Calendar.MINUTE, 33);
363 calendar.set(Calendar.SECOND, 44);
364 Time timeAfter = new java.sql.Time (calendar.getTime().getTime());
366
367 c = simpleHome.selectDynamic(
368 "SELECT OBJECT(s) " +
369 "FROM simple s " +
370 "WHERE s.timeValue BETWEEN ?1 AND ?2",
371 new Object []{timeBefore, timeAfter});
372 assertTrue(c.size() == 1);
373
374 }
375
376 public void testTimestampBetween() throws Exception
377 {
378 SimpleHome simpleHome = getSimpleHome();
379 Collection c;
380
381 Timestamp timestampBefore = new Timestamp (1111);
382 Timestamp timestampAfter = new Timestamp (8888);
383 c = simpleHome.selectDynamic(
384 "SELECT OBJECT(s) " +
385 "FROM simple s " +
386 "WHERE s.timestampValue BETWEEN ?1 AND ?2",
387 new Object []{timestampBefore, timestampAfter});
388 assertTrue(c.size() == 1);
389 }
390
391 public void testTimestampComparison() throws Exception
392 {
393 SimpleHome simpleHome = getSimpleHome();
394 Collection c;
395
396 Timestamp timestampBefore = new Timestamp (1111);
397 Timestamp timestampAfter = new Timestamp (8888);
398 c = simpleHome.selectDynamic(
399 "SELECT OBJECT(s) " +
400 "FROM simple s " +
401 "WHERE s.timestampValue >= ?1 AND s.timestampValue <= ?2",
402 new Object []{timestampBefore, timestampAfter});
403 assertTrue(c.size() == 1);
404 }
405
406 public void testTimestampIn() throws Exception
407 {
408 SimpleHome simpleHome = getSimpleHome();
409 Collection c;
410
411 Timestamp timestampBefore = new Timestamp (1111);
412 Timestamp timestampAfter = new Timestamp (8888);
413 c = simpleHome.selectDynamic(
414 "SELECT OBJECT(s) " +
415 "FROM simple s " +
416 "WHERE s.timestampValue IN(?1, ?2, ?3)",
417 new Object []{timestampBefore, timestampAfter, timestampValue});
418 assertTrue(c.size() == 1);
419 }
420
421
422 public void testStringBetween() throws Exception
423 {
424 SimpleHome simpleHome = getSimpleHome();
425 Collection c;
426
427 c = simpleHome.selectDynamic(
428 "SELECT OBJECT(s) " +
429 "FROM simple s " +
430 "WHERE UCASE(s.stringValue) BETWEEN UCASE(?1) AND UCASE(?2)",
431 new Object []{"aaaaa", "zzzzz"});
432 assertTrue(c.size() == 1);
433 }
434
435 public void testStringComparison() throws Exception
436 {
437 SimpleHome simpleHome = getSimpleHome();
438 Collection c;
439
440 c = simpleHome.selectDynamic(
441 "SELECT OBJECT(s) " +
442 "FROM simple s " +
443 "WHERE UCASE(s.stringValue) >= UCASE(?1) AND " +
444 " UCASE(s.stringValue) <= UCASE(?2)",
445 new Object []{"aaaaa", "zzzzz"});
446 assertTrue(c.size() == 1);
447 }
448
449 public void testStringIn() throws Exception
450 {
451 SimpleHome simpleHome = getSimpleHome();
452 Collection c;
453
454 c = simpleHome.selectDynamic(
455 "SELECT OBJECT(s) " +
456 "FROM simple s " +
457 "WHERE UCASE(s.stringValue) IN(UCASE(?1), UCASE(?2), " +
458 " UCASE('" + stringValue + "'))",
459 new Object []{"aaaaa", "zzzzz"});
460 assertTrue(c.size() == 1);
461 }
462
463 public void testLike() throws Exception
464 {
465 SimpleHome simpleHome = getSimpleHome();
466 Collection c;
467
468 c = simpleHome.selectDynamic(
469 "SELECT OBJECT(s) " +
470 "FROM simple s " +
471 "WHERE UCASE(s.stringValue) LIKE UCASE(?1)",
472 new Object []{"% string %"});
473 assertTrue(c.size() == 1);
474 }
475
476 public void testNumericIn() throws Exception
477 {
478 SimpleHome simpleHome = getSimpleHome();
479 Collection c;
480
481 c = simpleHome.selectDynamic(
482 "SELECT OBJECT(s) " +
483 "FROM simple s " +
484 "WHERE SQRT(s.longPrimitive) " +
485 " IN(SQRT(?1), SQRT(?2), SQRT( " + longPrimitive + " ) )",
486 new Object []{new Long (23094), new Long (20984)});
487 assertTrue(c.size() == 1);
488 }
489
490 public void testNumbericComparison() throws Exception
491 {
492 SimpleHome simpleHome = getSimpleHome();
493 Collection c;
494
495 c = simpleHome.selectDynamic(
496 "SELECT OBJECT(s) " +
497 "FROM simple s " +
498 "WHERE SQRT(s.longPrimitive) >= SQRT(?1) AND " +
499 " SQRT(s.longPrimitive) <= SQRT(?2)",
500 new Object []{new Long (22), new Long (20984)});
501 assertTrue(c.size() == 1);
502 }
503
504 public void testConcatFunction() throws Exception
505 {
506 SimpleHome simpleHome = getSimpleHome();
507 Collection c;
508
509 c = simpleHome.selectDynamic(
510 "SELECT OBJECT(s) " +
511 "FROM simple s " +
512 "WHERE CONCAT(?1, ?2) = ?3",
513 new Object []{
514 "foo",
515 "bar",
516 "foobar"}
517 );
518 assertTrue(c.size() == 1);
519 }
520
521 public void testLengthFunction() throws Exception
522 {
523 SimpleHome simpleHome = getSimpleHome();
524 Collection c;
525
526 c = simpleHome.selectDynamic(
527 "SELECT OBJECT(s) " +
528 "FROM simple s " +
529 "WHERE LENGTH(?1) = ?2",
530 new Object []{
531 "12345",
532 new Integer (5)}
533 );
534 assertTrue(c.size() == 1);
535 }
536
537 public void testSelectValueClass() throws Exception
538 {
539 SimpleHome simpleHome = getSimpleHome();
540 Collection c = simpleHome.selectValueClass();
541 assertEquals(1, c.size());
542
543 ValueClass v = (ValueClass) c.iterator().next();
544 assertEquals(valueClass, v);
545 }
546
547 public void testLocateFunction() throws Exception
548 {
549 SimpleHome simpleHome = getSimpleHome();
550 Collection c;
551
552 c = simpleHome.selectDynamic(
553 "SELECT OBJECT(s) " +
554 "FROM simple s " +
555 "WHERE LOCATE(?1, ?2, ?3) = ?4",
556 new Object []{
557 "x",
558 "1x34x67x90",
559 new Integer (3),
560 new Integer (5)}
561 );
562 assertTrue(c.size() == 1);
563
564 c = simpleHome.selectDynamic(
565 "SELECT OBJECT(s) " +
566 "FROM simple s " +
567 "WHERE LOCATE(?1, ?2) = ?3",
568 new Object []{
569 "x",
570 "1x34x67x90",
571 new Integer (2)}
572 );
573 assertTrue(c.size() == 1);
574
575 c = simpleHome.selectDynamic(
576 "SELECT OBJECT(s) " +
577 "FROM simple s " +
578 "WHERE LOCATE(?1, ?2, ?3) = ?4",
579 new Object []{
580 "z",
581 "1x34x67x90",
582 new Integer (3),
583 new Integer (0)}
584 );
585 assertTrue(c.size() == 1);
586 }
587
588
618
619 public void testFindWithByteArray() throws Exception
620 {
621 SimpleHome simpleHome = getSimpleHome();
622 Collection c = simpleHome.findWithByteArray(byteArrayValue);
623 assertEquals(1, c.size());
624
625 Simple s = (Simple) c.iterator().next();
626 assertTrue(s.isIdentical(simple));
627
628 assertEquals(booleanPrimitive, s.getBooleanPrimitive());
629 assertEquals(booleanObject, s.getBooleanObject());
630 assertEquals(bytePrimitive, s.getBytePrimitive());
631 assertEquals(byteObject, s.getByteObject());
632 assertEquals(shortPrimitive, s.getShortPrimitive());
633 assertEquals(shortObject, s.getShortObject());
634 assertEquals(integerPrimitive, s.getIntegerPrimitive());
635 assertEquals(integerObject, s.getIntegerObject());
636 assertEquals(longPrimitive, s.getLongPrimitive());
637 assertEquals(longObject, s.getLongObject());
638 assertEquals(floatPrimitive, s.getFloatPrimitive(), 0);
639 assertEquals(floatObject, s.getFloatObject());
640 assertEquals(doublePrimitive, s.getDoublePrimitive(), 0);
641 assertEquals(doubleObject, s.getDoubleObject());
642 assertEquals(stringValue, s.getStringValue());
643 assertTrue(
644 "expected :<" + simple.getUtilDateValue() + "> but was <" +
645 utilDateValue + ">",
646 utilDateValue.compareTo(simple.getUtilDateValue()) == 0);
647 assertTrue(
648 "expected :<" + simple.getSqlDateValue() + "> but was <" +
649 sqlDateValue + ">",
650 sqlDateValue.compareTo(simple.getSqlDateValue()) == 0);
651 assertTrue(
652 "expected :<" + simple.getTimeValue() + "> but was <" +
653 timeValue + ">",
654 timeValue.compareTo(simple.getTimeValue()) == 0);
655 assertTrue(
656 "expected :<" + simple.getTimestampValue() + "> but was <" +
657 timestampValue + ">",
658 timestampValue.compareTo(simple.getTimestampValue()) == 0);
659 assertTrue(
660 "expected :<" + simple.getBigDecimalValue() + "> but was <" +
661 bigDecimalValue + ">",
662 bigDecimalValue.compareTo(simple.getBigDecimalValue()) == 0);
663
664 byte[] array = simple.getByteArrayValue();
665 assertEquals(byteArrayValue.length, array.length);
666 for (int i = 0; i < array.length; i++)
667 {
668 assertEquals(byteArrayValue[i], array[i]);
669 }
670
671 assertEquals(valueClass, simple.getValueClass());
672 assertEquals(objectValue, simple.getObjectValue());
673 }
674
675 public void testDuplicateKey() throws Exception
676 {
677 try
678 {
679 SimpleHome simpleHome = getSimpleHome();
680 simpleHome.create("simple");
681 fail("Did not get DuplicateKeyException");
682 }
683 catch (DuplicateKeyException e)
684 {
685 }
687 }
688
689 public void testHashtable() throws Exception
690 {
691 simple.addToHashtable("key1", "value1");
692 simple.addToHashtable("key2", "value2");
693 Hashtable result = simple.getHashtable();
694 assertEquals(2, result.size());
695 }
696
697 public void testOptionAUpdate() throws Exception
698 {
699 InitialContext ctx = new InitialContext ();
700 SimpleHome home = (SimpleHome) ctx.lookup("cmp2/simple/SimpleA");
701 Simple simpleA = null;
702 try
703 {
704 simpleA = home.findByPrimaryKey("simpleA");
705 }
706 catch (Exception e)
707 {
708 simpleA = home.create("simpleA");
709 }
710
711 simpleA.setIntegerPrimitive(47);
712 int i = simpleA.getIntegerPrimitive();
713 assertTrue("i == 47 ", i == 47);
714 }
715
716 public void setUpEJB(Properties props) throws Exception
717 {
718 SimpleHome simpleHome = getSimpleHome();
719
720 boolean wasCreated = false;
721 try
722 {
723 simple = simpleHome.findByPrimaryKey("simple");
724 }
725 catch (Exception e)
726 {
727 }
728
729 if (simple == null)
730 {
731 simple = simpleHome.create("simple");
732 wasCreated = true;
733 }
734
735 simple.setBooleanPrimitive(booleanPrimitive);
736 simple.setBooleanObject(booleanObject);
737 simple.setBytePrimitive(bytePrimitive);
738 simple.setByteObject(byteObject);
739 simple.setShortPrimitive(shortPrimitive);
740 simple.setShortObject(shortObject);
741 simple.setIntegerPrimitive(integerPrimitive);
742 simple.setIntegerObject(integerObject);
743 simple.setLongPrimitive(longPrimitive);
744 simple.setLongObject(longObject);
745 simple.setFloatPrimitive(floatPrimitive);
746 simple.setFloatObject(floatObject);
747 simple.setDoublePrimitive(doublePrimitive);
748 simple.setDoubleObject(doubleObject);
749 simple.setStringValue(stringValue);
750 simple.setUtilDateValue(utilDateValue);
751 simple.setSqlDateValue(sqlDateValue);
752 simple.setTimeValue(timeValue);
753 simple.setTimestampValue(timestampValue);
754 if (wasCreated)
755 {
756 simple.setBigDecimalValue(bigDecimalValue);
757 simple.setByteArrayValue(byteArrayValue);
758 simple.setObjectValue(objectValue);
759 simple.setValueClass(valueClass);
760 simple.setHashtable(hashtable);
761 }
762 }
763
764 public void tearDownEJB(Properties props) throws Exception
765 {
766 simple.remove();
767 }
768 }
769 |
Popular Tags |
Java API By Example, From Geeks To Geeks.