|
1
17
18 package org.apache.geronimo.itest.client;
19
20 import javax.ejb.EJBHome  ;
21 import javax.ejb.EJBMetaData ;
22 import javax.ejb.EJBObject ;
23 import javax.ejb.Handle ;
24 import javax.naming.InitialContext ;
25
26 import junit.framework.TestCase;
27 import org.openejb.test.object.ObjectGraph;
28 import org.openejb.test.stateless.EncStatelessHome;
29 import org.openejb.test.stateless.EncStatelessObject;
30 import org.openejb.test.stateless.RmiIiopStatelessHome;
31 import org.openejb.test.stateless.RmiIiopStatelessObject;
32
33 public class EjbCommunicationTest extends TestCase {
34
35 private RmiIiopStatelessHome ejbHome;
36 private RmiIiopStatelessObject ejbObject;
37 private InitialContext initialContext;
38
39
40 protected void setUp() throws Exception {
41 initialContext = new InitialContext ();
42 Object obj = initialContext.lookup("java:comp/env/ejb/rmiiiopbean");
43 ejbHome = (RmiIiopStatelessHome) obj;
44 ejbObject = ejbHome.create();
45 }
46
47
48
49
50
51 public void testReturnStringObject() {
52 try {
53 String expected = new String ("1");
54 String actual = ejbObject.returnStringObject(expected);
55 assertEquals(expected, actual);
56 } catch (Exception e) {
57 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
58 }
59 }
60
61 public void testReturnStringObjectArray() {
62 try {
63 String [] expected = {"1", "2", "3"};
64 String [] actual = ejbObject.returnStringObjectArray(expected);
65
66 assertNotNull("The array returned is null", actual);
67 assertEquals(expected.length, actual.length);
68 for (int i = 0; i < actual.length; i++) {
69 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
70 }
71 } catch (Exception e) {
72 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
73 }
74 }
75
76
77
78
79
80 public void testReturnCharacterObject() {
81 try {
82 Character expected = new Character ('1');
83 Character actual = ejbObject.returnCharacterObject(expected);
84 assertEquals(expected, actual);
85 } catch (Exception e) {
86 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
87 }
88 }
89
90 public void testReturnCharacterPrimitive() {
91 try {
92 char expected = '1';
93 char actual = ejbObject.returnCharacterPrimitive(expected);
94 assertEquals(expected, actual);
95 } catch (Exception e) {
96 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
97 }
98 }
99
100 public void testReturnCharacterObjectArray() {
101 try {
102 Character [] expected = {new Character ('1'), new Character ('2'), new Character ('3')};
103 Character [] actual = ejbObject.returnCharacterObjectArray(expected);
104
105 assertNotNull("The array returned is null", actual);
106 assertEquals(expected.length, actual.length);
107 for (int i = 0; i < actual.length; i++) {
108 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
109 }
110 } catch (Exception e) {
111 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
112 }
113 }
114
115 public void testReturnCharacterPrimitiveArray() {
116 try {
117 char[] expected = {'1', '2', '3'};
118 char[] actual = ejbObject.returnCharacterPrimitiveArray(expected);
119
120 assertNotNull("The array returned is null", actual);
121 assertEquals(expected.length, actual.length);
122 for (int i = 0; i < actual.length; i++) {
123 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
124 }
125 } catch (Exception e) {
126 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
127 }
128 }
129
130
131
132
133
134
135 public void testReturnBooleanObject() {
136 try {
137 Boolean expected = new Boolean (true);
138 Boolean actual = ejbObject.returnBooleanObject(expected);
139 assertEquals(expected, actual);
140 } catch (Exception e) {
141 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
142 }
143 }
144
145 public void testReturnBooleanPrimitive() {
146 try {
147 boolean expected = true;
148 boolean actual = ejbObject.returnBooleanPrimitive(expected);
149 assertEquals("" + expected, "" + actual);
150 } catch (Exception e) {
151 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
152 }
153 }
154
155 public void testReturnBooleanObjectArray() {
156 try {
157 Boolean [] expected = {new Boolean (true), new Boolean (false), new Boolean (true)};
158 Boolean [] actual = ejbObject.returnBooleanObjectArray(expected);
159
160 assertNotNull("The array returned is null", actual);
161 assertEquals(expected.length, actual.length);
162 for (int i = 0; i < actual.length; i++) {
163 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
164 }
165 } catch (Exception e) {
166 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
167 }
168 }
169
170 public void testReturnBooleanPrimitiveArray() {
171 try {
172 boolean[] expected = {false, true, true};
173 boolean[] actual = ejbObject.returnBooleanPrimitiveArray(expected);
174
175 assertNotNull("The array returned is null", actual);
176 assertEquals(expected.length, actual.length);
177 for (int i = 0; i < actual.length; i++) {
178 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
179 }
180 } catch (Exception e) {
181 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
182 }
183 }
184
185
186
187
188
189
190 public void testReturnByteObject() {
191 try {
192 Byte expected = new Byte ("1");
193 Byte actual = ejbObject.returnByteObject(expected);
194 assertEquals(expected, actual);
195 } catch (Exception e) {
196 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
197 }
198 }
199
200 public void testReturnBytePrimitive() {
201 try {
202 byte expected = (byte) 1;
203 byte actual = ejbObject.returnBytePrimitive(expected);
204 assertEquals(expected, actual);
205 } catch (Exception e) {
206 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
207 }
208 }
209
210 public void testReturnByteObjectArray() {
211 try {
212 Byte [] expected = {new Byte ("1"), new Byte ("2"), new Byte ("3")};
213 Byte [] actual = ejbObject.returnByteObjectArray(expected);
214
215 assertNotNull("The array returned is null", actual);
216 assertEquals(expected.length, actual.length);
217 for (int i = 0; i < actual.length; i++) {
218 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
219 }
220 } catch (Exception e) {
221 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
222 }
223 }
224
225 public void testReturnBytePrimitiveArray() {
226 try {
227 byte[] expected = {(byte) 1, (byte) 2, (byte) 3};
228 byte[] actual = ejbObject.returnBytePrimitiveArray(expected);
229
230 assertNotNull("The array returned is null", actual);
231 assertEquals(expected.length, actual.length);
232 for (int i = 0; i < actual.length; i++) {
233 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
234 }
235 } catch (Exception e) {
236 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
237 }
238 }
239
240
241
242
243
244
245 public void testReturnShortObject() {
246 try {
247 Short expected = new Short ("1");
248 Short actual = ejbObject.returnShortObject(expected);
249 assertEquals(expected, actual);
250 } catch (Exception e) {
251 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
252 }
253 }
254
255 public void testReturnShortPrimitive() {
256 try {
257 short expected = (short) 1;
258 short actual = ejbObject.returnShortPrimitive(expected);
259 assertEquals(expected, actual);
260 } catch (Exception e) {
261 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
262 }
263 }
264
265 public void testReturnShortObjectArray() {
266 try {
267 Short [] expected = {new Short ("1"), new Short ("2"), new Short ("3")};
268 Short [] actual = ejbObject.returnShortObjectArray(expected);
269
270 assertNotNull("The array returned is null", actual);
271 assertEquals(expected.length, actual.length);
272 for (int i = 0; i < actual.length; i++) {
273 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
274 }
275 } catch (Exception e) {
276 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
277 }
278 }
279
280 public void testReturnShortPrimitiveArray() {
281 try {
282 short[] expected = {(short) 1, (short) 2, (short) 3};
283 short[] actual = ejbObject.returnShortPrimitiveArray(expected);
284
285 assertNotNull("The array returned is null", actual);
286 assertEquals(expected.length, actual.length);
287 for (int i = 0; i < actual.length; i++) {
288 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
289 }
290 } catch (Exception e) {
291 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
292 }
293 }
294
295
296
297
298
299
300 public void testReturnIntegerObject() {
301 try {
302 Integer expected = new Integer (1);
303 Integer actual = ejbObject.returnIntegerObject(expected);
304 assertEquals(expected, actual);
305 } catch (Exception e) {
306 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
307 }
308 }
309
310 public void testReturnIntegerPrimitive() {
311 try {
312 int expected = 1;
313 int actual = ejbObject.returnIntegerPrimitive(expected);
314 assertEquals(expected, actual);
315 } catch (Exception e) {
316 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
317 }
318 }
319
320 public void testReturnIntegerObjectArray() {
321 try {
322 Integer [] expected = {new Integer (1), new Integer (2), new Integer (3)};
323 Integer [] actual = ejbObject.returnIntegerObjectArray(expected);
324
325 assertNotNull("The array returned is null", actual);
326 assertEquals(expected.length, actual.length);
327 for (int i = 0; i < actual.length; i++) {
328 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
329 }
330 } catch (Exception e) {
331 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
332 }
333 }
334
335 public void testReturnIntegerPrimitiveArray() {
336 try {
337 int[] expected = {1, 2, 3};
338 int[] actual = ejbObject.returnIntegerPrimitiveArray(expected);
339
340 assertNotNull("The array returned is null", actual);
341 assertEquals(expected.length, actual.length);
342 for (int i = 0; i < actual.length; i++) {
343 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
344 }
345 } catch (Exception e) {
346 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
347 }
348 }
349
350
351
352
353
354
355 public void testReturnLongObject() {
356 try {
357 Long expected = new Long ("1");
358 Long actual = ejbObject.returnLongObject(expected);
359 assertEquals(expected, actual);
360 } catch (Exception e) {
361 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
362 }
363 }
364
365 public void testReturnLongPrimitive() {
366 try {
367 long expected = 1;
368 long actual = ejbObject.returnLongPrimitive(expected);
369 assertEquals(expected, actual);
370 } catch (Exception e) {
371 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
372 }
373 }
374
375 public void testReturnLongObjectArray() {
376 try {
377 Long [] expected = {new Long ("1"), new Long ("2"), new Long ("3")};
378 Long [] actual = ejbObject.returnLongObjectArray(expected);
379
380 assertNotNull("The array returned is null", actual);
381 assertEquals(expected.length, actual.length);
382 for (int i = 0; i < actual.length; i++) {
383 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
384 }
385 } catch (Exception e) {
386 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
387 }
388 }
389
390 public void testReturnLongPrimitiveArray() {
391 try {
392 long[] expected = {1, 2, 3};
393 long[] actual = ejbObject.returnLongPrimitiveArray(expected);
394
395 assertNotNull("The array returned is null", actual);
396 assertEquals(expected.length, actual.length);
397 for (int i = 0; i < actual.length; i++) {
398 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
399 }
400 } catch (Exception e) {
401 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
402 }
403 }
404
405
406
407
408
409
410 public void testReturnFloatObject() {
411 try {
412 Float expected = new Float ("1.3");
413 Float actual = ejbObject.returnFloatObject(expected);
414 assertEquals(expected, actual);
415 } catch (Exception e) {
416 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
417 }
418 }
419
420 public void testReturnFloatPrimitive() {
421 try {
422 float expected = 1.2F;
423 float actual = ejbObject.returnFloatPrimitive(expected);
424 assertEquals(expected, actual, 0.00D);
425 } catch (Exception e) {
426 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
427 }
428 }
429
430 public void testReturnFloatObjectArray() {
431 try {
432 Float [] expected = {new Float ("1.1"), new Float ("2.2"), new Float ("3.3")};
433 Float [] actual = ejbObject.returnFloatObjectArray(expected);
434
435 assertNotNull("The array returned is null", actual);
436 assertEquals(expected.length, actual.length);
437 for (int i = 0; i < actual.length; i++) {
438 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
439 }
440 } catch (Exception e) {
441 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
442 }
443 }
444
445 public void testReturnFloatPrimitiveArray() {
446 try {
447 float[] expected = {1.2F, 2.3F, 3.4F};
448 float[] actual = ejbObject.returnFloatPrimitiveArray(expected);
449
450 assertNotNull("The array returned is null", actual);
451 assertEquals(expected.length, actual.length);
452 for (int i = 0; i < actual.length; i++) {
453 assertEquals("Array values are not equal at index " + i, expected[i], actual[i], 0.0D);
454 }
455 } catch (Exception e) {
456 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
457 }
458 }
459
460
461
462
463
464
465 public void testReturnDoubleObject() {
466 try {
467 Double expected = new Double ("1.1");
468 Double actual = ejbObject.returnDoubleObject(expected);
469 assertEquals(expected, actual);
470 } catch (Exception e) {
471 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
472 }
473 }
474
475 public void testReturnDoublePrimitive() {
476 try {
477 double expected = 1.2;
478 double actual = ejbObject.returnDoublePrimitive(expected);
479 assertEquals(expected, actual, 0.0D);
480 } catch (Exception e) {
481 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
482 }
483 }
484
485 public void testReturnDoubleObjectArray() {
486 try {
487 Double [] expected = {new Double ("1.3"), new Double ("2.4"), new Double ("3.5")};
488 Double [] actual = ejbObject.returnDoubleObjectArray(expected);
489
490 assertNotNull("The array returned is null", actual);
491 assertEquals(expected.length, actual.length);
492 for (int i = 0; i < actual.length; i++) {
493 assertEquals("Array values are not equal at index " + i, expected[i], actual[i]);
494 }
495 } catch (Exception e) {
496 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
497 }
498 }
499
500 public void testReturnDoublePrimitiveArray() {
501 try {
502 double[] expected = {1.4, 2.5, 3.6};
503 double[] actual = ejbObject.returnDoublePrimitiveArray(expected);
504
505 assertNotNull("The array returned is null", actual);
506 assertEquals(expected.length, actual.length);
507 for (int i = 0; i < actual.length; i++) {
508 assertEquals("Array values are not equal at index " + i, expected[i], actual[i], 0.0D);
509 }
510 } catch (Exception e) {
511 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
512 }
513 }
514
515
516
517
518
519
520 public void testReturnEJBHome() {
521 try {
522 Object obj = initialContext.lookup("client/tests/stateless/EncBean");
523 EncStatelessHome expected = (EncStatelessHome) obj;
524 assertNotNull("The EJBHome returned from JNDI is null", expected);
525
526 EncStatelessHome actual = (EncStatelessHome) ejbObject.returnEJBHome(expected);
527 assertNotNull("The EJBHome returned is null", actual);
528
529 } catch (Exception e) {
530 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
531 }
532 }
533
534 public void testReturnEJBHome2() {
535 try {
536 EncStatelessHome actual = (EncStatelessHome) ejbObject.returnEJBHome();
537 assertNotNull("The EJBHome returned is null", actual);
538
539 } catch (Exception e) {
540 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
541 }
542 }
543
544 public void testReturnNestedEJBHome() {
545 try {
546 Object obj = initialContext.lookup("client/tests/stateless/EncBean");
547 EncStatelessHome expected = (EncStatelessHome) obj;
548 assertNotNull("The EJBHome returned from JNDI is null", expected);
549
550 ObjectGraph graph = ejbObject.returnObjectGraph(new ObjectGraph(expected));
551 assertNotNull("The ObjectGraph is null", graph);
552
553 EncStatelessHome actual = (EncStatelessHome) graph.getObject();
554 assertNotNull("The EJBHome returned is null", actual);
555 } catch (Exception e) {
556 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
557 }
558 }
559
560 public void testReturnNestedEJBHome2() {
561 try {
562 ObjectGraph graph = ejbObject.returnNestedEJBHome();
563 assertNotNull("The ObjectGraph is null", graph);
564
565 EncStatelessHome actual = (EncStatelessHome) graph.getObject();
566 assertNotNull("The EJBHome returned is null", actual);
567 } catch (Exception e) {
568 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
569 }
570 }
571
572 public void XtestReturnEJBHomeArray() {
573 try {
574
575 EncStatelessHome expected[] = new EncStatelessHome[3];
576 for (int i = 0; i < expected.length; i++) {
577 Object obj = initialContext.lookup("client/tests/stateless/EncBean");
578 expected[i] = (EncStatelessHome) obj;
579 assertNotNull("The EJBHome returned from JNDI is null", expected[i]);
580 }
581
582 EJBHome [] actual = ejbObject.returnEJBHomeArray(expected);
583 assertNotNull("The EJBHome array returned is null", actual);
584 assertEquals(expected.length, actual.length);
585
586 } catch (Exception e) {
587 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
588 }
589 }
590
591
592
593
594
595
596 public void testReturnEJBObject() {
597 try {
598 Object obj = initialContext.lookup("client/tests/stateless/EncBean");
599 EncStatelessHome home = (EncStatelessHome) obj;
600 assertNotNull("The EJBHome returned from JNDI is null", home);
601
602 EncStatelessObject expected = home.create();
603 assertNotNull("The EJBObject created is null", expected);
604
605 EncStatelessObject actual = (EncStatelessObject) ejbObject.returnEJBObject(expected);
606 assertNotNull("The EJBObject returned is null", actual);
607
608 assertTrue("The EJBObejcts are not identical", expected.isIdentical(actual));
609 } catch (Exception e) {
610 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
611 }
612 }
613
614 public void testReturnEJBObject2() {
615 try {
616 EncStatelessObject actual = (EncStatelessObject) ejbObject.returnEJBObject();
617 assertNotNull("The EJBObject returned is null", actual);
618
619 } catch (Exception e) {
620 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
621 }
622 }
623
624 public void testReturnNestedEJBObject() {
625 try {
626 Object obj = initialContext.lookup("client/tests/stateless/EncBean");
627 EncStatelessHome home = (EncStatelessHome) obj;
628 assertNotNull("The EJBHome returned from JNDI is null", home);
629
630 EncStatelessObject expected = home.create();
631 assertNotNull("The EJBObject created is null", expected);
632
633 ObjectGraph graph = ejbObject.returnObjectGraph(new ObjectGraph(expected));
634 assertNotNull("The ObjectGraph is null", graph);
635
636 EncStatelessObject actual = (EncStatelessObject) graph.getObject();
637 assertNotNull("The EJBObject returned is null", actual);
638
639 assertTrue("The EJBObejcts are not identical", expected.isIdentical(actual));
640 } catch (Exception e) {
641 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
642 }
643 }
644
645 public void testReturnNestedEJBObject2() {
646 try {
647 ObjectGraph graph = ejbObject.returnNestedEJBObject();
648 assertNotNull("The ObjectGraph is null", graph);
649
650 EncStatelessObject actual = (EncStatelessObject) graph.getObject();
651 assertNotNull("The EJBHome returned is null", actual);
652 } catch (Exception e) {
653 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
654 }
655 }
656
657 public void XtestReturnEJBObjectArray() {
658 try {
659 Object obj = initialContext.lookup("client/tests/stateless/EncBean");
660 EncStatelessHome home = (EncStatelessHome) obj;
661 assertNotNull("The EJBHome returned from JNDI is null", home);
662
663 EncStatelessObject expected[] = new EncStatelessObject[3];
664 for (int i = 0; i < expected.length; i++) {
665 expected[i] = home.create();
666 assertNotNull("The EJBObject created is null", expected[i]);
667 }
668
669 EJBObject [] actual = ejbObject.returnEJBObjectArray(expected);
670 assertNotNull("The EJBObject array returned is null", actual);
671 assertEquals(expected.length, actual.length);
672
673 for (int i = 0; i < actual.length; i++) {
674 assertTrue("The EJBObejcts are not identical", expected[i].isIdentical(actual[i]));
675 }
676
677 } catch (Exception e) {
678 fail("Received Exception " + e.getClass() + " : " + e.getMessage());
679 }
680 }
681
682
683
684
685
686 public void testReturnEJBMetaData() {
687 try {
688 Object obj = initialContext.lookup("client/tests/stateless/EncBean");
689 EncStatelessHome home = (EncStatelessHome) obj;
690 assertNotNull("The EJBHome returned from JNDI is null", home);
691
692 EJBMetaData expected = home.getEJBMetaData();
693 assertNotNull("The EJBMetaData returned is null", expected);
694
695 EJBMetaData actual = ejbObject.returnEJBMetaData(expected);
696 assertNotNull("The EJBMetaData returned is null", actual);
697 assertEquals(expected.getHomeInterfaceClass(), actual.getHomeInterfaceClass());
698 assertEquals(expected.getRemoteInterfaceClass(), actual.getRemoteInterfaceClass());
699 } catch (Exception e) {
700 fail("Received Exception " + e.get
|
Java API By Example, From Geeks To Geeks.