KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > test > iiop > test > ParameterPassingStressTestCase


1 /*
2   * JBoss, Home of Professional Open Source
3   * Copyright 2005, JBoss Inc., and individual contributors as indicated
4   * by the @authors tag. See the copyright.txt in the distribution for a
5   * full listing of individual contributors.
6   *
7   * This is free software; you can redistribute it and/or modify it
8   * under the terms of the GNU Lesser General Public License as
9   * published by the Free Software Foundation; either version 2.1 of
10   * the License, or (at your option) any later version.
11   *
12   * This software is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * Lesser General Public License for more details.
16   *
17   * You should have received a copy of the GNU Lesser General Public
18   * License along with this software; if not, write to the Free
19   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
20   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
21   */

22 package org.jboss.test.iiop.test;
23
24
25 import java.rmi.Remote JavaDoc;
26 import javax.rmi.PortableRemoteObject JavaDoc;
27
28 import junit.framework.Assert;
29 import junit.framework.Test;
30 import org.jboss.test.JBossIIOPTestCase;
31 import org.jboss.test.iiop.interfaces.Boo;
32 import org.jboss.test.iiop.interfaces.Foo;
33 import org.jboss.test.iiop.interfaces.IdlInterface;
34 import org.jboss.test.iiop.interfaces.IdlInterfaceHelper;
35 import org.jboss.test.iiop.interfaces.NegativeArgumentException;
36 import org.jboss.test.iiop.interfaces.StatelessSession;
37 import org.jboss.test.iiop.interfaces.StatelessSessionHome;
38 import org.jboss.test.iiop.interfaces.Zoo;
39 import org.jboss.test.iiop.util.Util;
40 import org.omg.CORBA.ORB JavaDoc;
41 import org.omg.PortableServer.POA JavaDoc;
42 import org.omg.PortableServer.POAHelper JavaDoc;
43
44 /**
45  * @author reverbel@ime.usp.br
46  * @version $Revision: 37406 $
47  */

48 public class ParameterPassingStressTestCase
49    extends JBossIIOPTestCase
50 {
51    // Constants -----------------------------------------------------
52

53    // Attributes ----------------------------------------------------
54

55    // Static --------------------------------------------------------
56

57    // Constructors --------------------------------------------------
58
public ParameterPassingStressTestCase(String JavaDoc name)
59    {
60       super(name);
61    }
62    
63    // Public --------------------------------------------------------
64

65    public void test_getString()
66       throws Exception JavaDoc
67    {
68       StatelessSessionHome home =
69          (StatelessSessionHome)PortableRemoteObject.narrow(
70                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
71                     StatelessSessionHome.class);
72       StatelessSession session = home.create();
73       //----------------------------------------------------------------------
74
String JavaDoc s = session.getString();
75       assertEquals(Util.STRING, s);
76       //----------------------------------------------------------------------
77
session.remove();
78    }
79
80    public void test_PrimitiveTypes()
81       throws Exception JavaDoc
82    {
83       StatelessSessionHome home =
84          (StatelessSessionHome)PortableRemoteObject.narrow(
85                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
86                     StatelessSessionHome.class);
87       StatelessSession session = home.create();
88       //----------------------------------------------------------------------
89
String JavaDoc s;
90       s = session.testPrimitiveTypes(false,
91                                      'A',
92                                      Byte.MIN_VALUE,
93                                      Short.MIN_VALUE,
94                                      Integer.MIN_VALUE,
95                                      Long.MIN_VALUE,
96                                      Float.MIN_VALUE,
97                                      Double.MIN_VALUE);
98       assertEquals(Util.primitiveTypesToString(false,
99                                                'A',
100                                                Byte.MIN_VALUE,
101                                                Short.MIN_VALUE,
102                                                Integer.MIN_VALUE,
103                                                Long.MIN_VALUE,
104                                                Float.MIN_VALUE,
105                                                Double.MIN_VALUE),
106                    s);
107       s = session.testPrimitiveTypes(true,
108                                      'Z',
109                                      Byte.MAX_VALUE,
110                                      Short.MAX_VALUE,
111                                      Integer.MAX_VALUE,
112                                      Long.MAX_VALUE,
113                                      Float.MAX_VALUE,
114                                      Double.MAX_VALUE);
115       assertEquals(Util.primitiveTypesToString(true,
116                                                'Z',
117                                                Byte.MAX_VALUE,
118                                                Short.MAX_VALUE,
119                                                Integer.MAX_VALUE,
120                                                Long.MAX_VALUE,
121                                                Float.MAX_VALUE,
122                                                Double.MAX_VALUE),
123                    s);
124       //----------------------------------------------------------------------
125
session.remove();
126    }
127
128    public void test_String()
129       throws Exception JavaDoc
130    {
131       StatelessSessionHome home =
132          (StatelessSessionHome)PortableRemoteObject.narrow(
133                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
134                     StatelessSessionHome.class);
135       StatelessSession session = home.create();
136       //----------------------------------------------------------------------
137
String JavaDoc original = "0123456789";
138       String JavaDoc echoedBack = session.testString(original);
139       assertEquals(Util.echo(original), echoedBack);
140       //----------------------------------------------------------------------
141
session.remove();
142    }
143
144    public void test_StatelessSession()
145       throws Exception JavaDoc
146    {
147       StatelessSessionHome home =
148          (StatelessSessionHome)PortableRemoteObject.narrow(
149                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
150                     StatelessSessionHome.class);
151       StatelessSession session = home.create();
152       //----------------------------------------------------------------------
153
StatelessSession session2 =
154          session.testStatelessSession("the quick brown fox", session);
155       String JavaDoc s = session2.getString();
156       assertEquals(Util.STRING, s);
157       //----------------------------------------------------------------------
158
session.remove();
159    }
160    
161    public void test_Remote()
162       throws Exception JavaDoc
163    {
164       StatelessSessionHome home =
165          (StatelessSessionHome)PortableRemoteObject.narrow(
166                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
167                     StatelessSessionHome.class);
168       StatelessSession session = home.create();
169       //----------------------------------------------------------------------
170
Remote JavaDoc r = session.testRemote("jumps over the lazy dog", session);
171       StatelessSession session2 =
172          (StatelessSession)PortableRemoteObject.narrow(r,
173                                                        StatelessSession.class);
174       String JavaDoc s = session2.getString();
175       assertEquals(Util.STRING, s);
176       //----------------------------------------------------------------------
177
session.remove();
178    }
179    
180    public void test_Serializable()
181       throws Exception JavaDoc
182    {
183       StatelessSessionHome home =
184          (StatelessSessionHome)PortableRemoteObject.narrow(
185                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
186                     StatelessSessionHome.class);
187       StatelessSession session = home.create();
188       //----------------------------------------------------------------------
189
Foo original = new Foo(7, "foo test");
190       Foo echoedBack = session.testSerializable(original);
191       assertEquals(Util.echoFoo(original), echoedBack);
192       //----------------------------------------------------------------------
193
session.remove();
194    }
195    
196    public void test_intArray()
197       throws Exception JavaDoc
198    {
199       StatelessSessionHome home =
200          (StatelessSessionHome)PortableRemoteObject.narrow(
201                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
202                     StatelessSessionHome.class);
203       StatelessSession session = home.create();
204       //----------------------------------------------------------------------
205
int[] original= new int[10];
206       for (int i = 0; i < original.length; i++)
207          original[i] = 100 + i;
208       int[] echoedBack = session.testIntArray(original);
209       assertEquals(original.length, echoedBack.length);
210       for (int i = 0; i < echoedBack.length; i++)
211          assertEquals(original[i] + 1, echoedBack[i]);
212       //----------------------------------------------------------------------
213
session.remove();
214    }
215    
216    public void test_valueArray()
217       throws Exception JavaDoc
218    {
219       StatelessSessionHome home =
220          (StatelessSessionHome)PortableRemoteObject.narrow(
221                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
222                     StatelessSessionHome.class);
223       StatelessSession session = home.create();
224       //----------------------------------------------------------------------
225
Foo[] original = new Foo[4];
226       for (int i = 0; i < original.length; i++)
227          original[i] = new Foo(100 + i, "foo array test");
228       Foo[] echoedBack = session.testValueArray(original);
229       assertEquals(original.length, echoedBack.length);
230       for (int i = 0; i < echoedBack.length; i++)
231          assertEquals(Util.echoFoo(original[i]), echoedBack[i]);
232       //----------------------------------------------------------------------
233
session.remove();
234    }
235    
236    public void test_exception()
237       throws Exception JavaDoc
238    {
239       StatelessSessionHome home =
240          (StatelessSessionHome)PortableRemoteObject.narrow(
241                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
242                     StatelessSessionHome.class);
243       StatelessSession session = home.create();
244       //----------------------------------------------------------------------
245
assertEquals("#0", session.testException(0));
246       assertEquals("#1", session.testException(1));
247       assertEquals("#2", session.testException(2));
248       try
249       {
250          session.testException(-2);
251          fail("NegativeArgumentException expected but not thrown.");
252       }
253       catch (NegativeArgumentException na)
254       {
255          assertEquals(-2, na.getNegativeArgument());
256       }
257       try
258       {
259          session.testException(-1);
260          fail("NegativeArgumentException expected but not thrown.");
261       }
262       catch (NegativeArgumentException na)
263       {
264          assertEquals(-1, na.getNegativeArgument());
265       }
266       assertEquals("#0", session.testException(0));
267       //----------------------------------------------------------------------
268
session.remove();
269    }
270    
271    public void test_FooValueToObject()
272       throws Exception JavaDoc
273    {
274       StatelessSessionHome home =
275          (StatelessSessionHome)PortableRemoteObject.narrow(
276                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
277                     StatelessSessionHome.class);
278       StatelessSession session = home.create();
279       //----------------------------------------------------------------------
280
Foo original = new Foo(9999, "foo test");
281       java.lang.Object JavaDoc echoedBack = session.fooValueToObject(original);
282       assertEquals(Util.echoFoo(original), echoedBack);
283       //----------------------------------------------------------------------
284
session.remove();
285    }
286    
287    public void test_BooValueToObject()
288       throws Exception JavaDoc
289    {
290       StatelessSessionHome home =
291          (StatelessSessionHome)PortableRemoteObject.narrow(
292                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
293                     StatelessSessionHome.class);
294       StatelessSession session = home.create();
295       //----------------------------------------------------------------------
296
Boo original = new Boo("t1", "boo test");
297       java.lang.Object JavaDoc echoedBack = session.booValueToObject(original);
298       assertEquals(Util.echoBoo(original), echoedBack);
299       //----------------------------------------------------------------------
300
session.remove();
301    }
302    
303    public void test_valueArrayToVector()
304       throws Exception JavaDoc
305    {
306       StatelessSessionHome home =
307          (StatelessSessionHome)PortableRemoteObject.narrow(
308                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
309                     StatelessSessionHome.class);
310       StatelessSession session = home.create();
311       //----------------------------------------------------------------------
312
Foo[] original = new Foo[4];
313       for (int i = 0; i < original.length; i++)
314          original[i] = new Foo(100 + i, "foo vector test");
315       java.util.Vector JavaDoc v = session.valueArrayToVector(original);
316       java.lang.Object JavaDoc[] echoedBack = v.toArray();
317       assertEquals(original.length, echoedBack.length);
318       for (int i = 0; i < echoedBack.length; i++)
319          assertEquals(Util.echoFoo(original[i]), echoedBack[i]);
320       //----------------------------------------------------------------------
321
session.remove();
322    }
323    
324    public void test_vectorToValueArray()
325       throws Exception JavaDoc
326    {
327       StatelessSessionHome home =
328          (StatelessSessionHome)PortableRemoteObject.narrow(
329                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
330                     StatelessSessionHome.class);
331       StatelessSession session = home.create();
332       //----------------------------------------------------------------------
333
Foo[] original = new Foo[4];
334       for (int i = 0; i < original.length; i++)
335          original[i] = new Foo(100 + i, "foo vector test");
336       java.util.Vector JavaDoc v = session.valueArrayToVector(original);
337       Foo[] echoedBack = session.vectorToValueArray(v);
338       assertEquals(original.length, echoedBack.length);
339       for (int i = 0; i < echoedBack.length; i++)
340          assertEquals(Util.echoFoo(Util.echoFoo(original[i])),
341                       echoedBack[i]);
342       //----------------------------------------------------------------------
343
session.remove();
344    }
345    
346    public void test_getException()
347       throws Exception JavaDoc
348    {
349       StatelessSessionHome home =
350          (StatelessSessionHome)PortableRemoteObject.narrow(
351                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
352                     StatelessSessionHome.class);
353       StatelessSession session = home.create();
354       //----------------------------------------------------------------------
355
java.lang.Object JavaDoc obj = session.getException();
356       NegativeArgumentException na = (NegativeArgumentException)obj;
357       assertEquals(-7777, na.getNegativeArgument());
358       //----------------------------------------------------------------------
359
session.remove();
360    }
361    
362    public void test_getZooValue()
363       throws Exception JavaDoc
364    {
365       StatelessSessionHome home =
366          (StatelessSessionHome)PortableRemoteObject.narrow(
367                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
368                     StatelessSessionHome.class);
369       StatelessSession session = home.create();
370       //----------------------------------------------------------------------
371
java.lang.Object JavaDoc obj = session.getZooValue();
372       Assert.assertEquals(new Zoo("outer_zoo!",
373                                   "returned by getZooValue",
374                                   new Zoo("inner_zoo!", "inner")),
375                           obj);
376       //----------------------------------------------------------------------
377
session.remove();
378    }
379    
380    public void test_referenceSharingWithinArray()
381       throws Exception JavaDoc
382    {
383       StatelessSessionHome home =
384          (StatelessSessionHome)PortableRemoteObject.narrow(
385                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
386                     StatelessSessionHome.class);
387       StatelessSession session = home.create();
388       //----------------------------------------------------------------------
389
int n = 100;
390       Object JavaDoc[] original = new Object JavaDoc[n];
391       for (int i = 0; i < n; i++)
392          original[i] = new Boo("t" + i, "boo array test");
393       Object JavaDoc[] echoedBack =
394          session.testReferenceSharingWithinArray(original);
395       assertEquals(2 * n, echoedBack.length);
396       for (int i = 0; i < n; i++)
397       {
398          assertEquals(original[i], echoedBack[i]);
399          assertEquals(original[i], echoedBack[i + n]);
400          assertSame(echoedBack[i], echoedBack[i + n]);
401       }
402       //----------------------------------------------------------------------
403
session.remove();
404    }
405    
406    public void test_referenceSharingWithinCollection()
407       throws Exception JavaDoc
408    {
409       StatelessSessionHome home =
410          (StatelessSessionHome)PortableRemoteObject.narrow(
411                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
412                     StatelessSessionHome.class);
413       StatelessSession session = home.create();
414       //----------------------------------------------------------------------
415
java.util.Collection JavaDoc original = new java.util.ArrayList JavaDoc();
416       int n = 10;
417       for (int i = 0; i < n; i++)
418          original.add(new Foo(100 + i, "foo collection test"));
419       java.util.Collection JavaDoc echoedBack =
420          session.testReferenceSharingWithinCollection(original);
421       assertEquals(2 * n, echoedBack.size());
422       java.util.ArrayList JavaDoc originalList = (java.util.ArrayList JavaDoc)original;
423       java.util.ArrayList JavaDoc echoedList = (java.util.ArrayList JavaDoc)echoedBack;
424       for (int i = 0; i < n; i++)
425       {
426          assertEquals(originalList.get(i), echoedList.get(i));
427          assertEquals(originalList.get(i), echoedList.get(i + n));
428          assertSame(echoedList.get(i), echoedList.get(i + n));
429       }
430       //----------------------------------------------------------------------
431
session.remove();
432    }
433
434    public void test_bigVector()
435       throws Exception JavaDoc
436    {
437       StatelessSessionHome home =
438          (StatelessSessionHome)PortableRemoteObject.narrow(
439                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
440                     StatelessSessionHome.class);
441       StatelessSession session = home.create();
442       //----------------------------------------------------------------------
443
Foo[] original = new Foo[256];
444       for (int i = 0; i < original.length; i++)
445          original[i] = new Foo(100 + i, "foo vector test");
446       java.util.Vector JavaDoc v = session.valueArrayToVector(original);
447       Foo[] echoedBack = session.vectorToValueArray(v);
448       assertEquals(original.length, echoedBack.length);
449       for (int i = 0; i < echoedBack.length; i++)
450          assertEquals(Util.echoFoo(Util.echoFoo(original[i])),
451                       echoedBack[i]);
452       //----------------------------------------------------------------------
453
session.remove();
454    }
455
456    public void test_CorbaObject()
457       throws Exception JavaDoc
458    {
459       StatelessSessionHome home =
460          (StatelessSessionHome)PortableRemoteObject.narrow(
461                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
462                     StatelessSessionHome.class);
463       StatelessSession session = home.create();
464       //----------------------------------------------------------------------
465
final ORB JavaDoc orb = ORB.init(new String JavaDoc[0], System.getProperties());
466       POA JavaDoc poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
467       IdlInterfaceServant servant = new IdlInterfaceServant();
468       org.omg.CORBA.Object JavaDoc original = servant._this_object(orb);
469       poa.the_POAManager().activate();
470       new Thread JavaDoc(
471          new Runnable JavaDoc() {
472             public void run() {
473                orb.run();
474             }
475          },
476          "ORB thread"
477       ).start();
478       org.omg.CORBA.Object JavaDoc echoedBack = session.testCorbaObject(original);
479       assertEquals(orb.object_to_string(original),
480                    orb.object_to_string(echoedBack));
481       //----------------------------------------------------------------------
482
session.remove();
483    }
484    
485    public void test_IdlInterface()
486       throws Exception JavaDoc
487    {
488       StatelessSessionHome home =
489          (StatelessSessionHome)PortableRemoteObject.narrow(
490                     getInitialContext().lookup(StatelessSessionHome.JNDI_NAME),
491                     StatelessSessionHome.class);
492       StatelessSession session = home.create();
493       //----------------------------------------------------------------------
494
final ORB JavaDoc orb = ORB.init(new String JavaDoc[0], System.getProperties());
495       POA JavaDoc poa = POAHelper.narrow(orb.resolve_initial_references("RootPOA"));
496       IdlInterfaceServant servant = new IdlInterfaceServant();
497       org.omg.CORBA.Object JavaDoc obj = servant._this_object(orb);
498       poa.the_POAManager().activate();
499       new Thread JavaDoc(
500          new Runnable JavaDoc() {
501             public void run() {
502                orb.run();
503             }
504          },
505          "ORB thread"
506       ).start();
507       IdlInterface original = IdlInterfaceHelper.narrow(obj);
508       IdlInterface echoedBack = session.testIdlInterface(original);
509       assertEquals(orb.object_to_string(original),
510                    orb.object_to_string(echoedBack));
511       
512       //----------------------------------------------------------------------
513
session.remove();
514    }
515    
516    public static Test suite() throws Exception JavaDoc
517    {
518       return getDeploySetup(ParameterPassingStressTestCase.class, "iiop.jar");
519    }
520
521 }
522
Popular Tags