1 //
2 // Copyright (c) ZeroC, Inc. All rights reserved.
3 //
4 
5 package test.Ice.optional;
6 import java.io.PrintWriter;
7 
8 import test.Ice.optional.Test.*;
9 
10 public class AllTests
11 {
12     private static void
test(boolean b)13     test(boolean b)
14     {
15         if(!b)
16         {
17             throw new RuntimeException();
18         }
19     }
20 
21     public static InitialPrx
allTests(test.TestHelper helper, boolean collocated)22     allTests(test.TestHelper helper, boolean collocated)
23     {
24         PrintWriter out = helper.getWriter();
25         Ice.Communicator communicator = helper.communicator();
26 
27         FactoryI factory = new FactoryI();
28         communicator.getValueFactoryManager().add(factory, "");
29 
30         out.print("testing stringToProxy... ");
31         out.flush();
32         String ref = "initial:" + helper.getTestEndpoint(0);
33         Ice.ObjectPrx base = communicator.stringToProxy(ref);
34         test(base != null);
35         out.println("ok");
36 
37         out.print("testing checked cast... ");
38         out.flush();
39         InitialPrx initial = InitialPrxHelper.checkedCast(base);
40         test(initial != null);
41         test(initial.equals(base));
42         out.println("ok");
43 
44         out.print("testing optional data members... ");
45         out.flush();
46 
47         OneOptional oo1 = new OneOptional();
48         test(!oo1.hasA());
49         oo1.setA(15);
50         test(oo1.hasA() && oo1.getA() == 15);
51 
52         OneOptional oo2 = new OneOptional(16);
53         test(oo2.hasA() && oo2.getA() == 16);
54 
55         MultiOptional mo1 = new MultiOptional();
56         mo1.setA((byte)15);
57         mo1.setB(true);
58         mo1.setC((short)19);
59         mo1.setD(78);
60         mo1.setE(99);
61         mo1.setF((float)5.5);
62         mo1.setG(1.0);
63         mo1.setH("test");
64         mo1.setI(MyEnum.MyEnumMember);
65         mo1.setJ(MultiOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test")));
66         mo1.setK(mo1);
67         mo1.setBs(new byte[] { (byte)5 });
68         mo1.setSs(new String[] { "test", "test2" });
69         mo1.setIid(new java.util.HashMap<Integer, Integer>());
70         mo1.getIid().put(4, 3);
71         mo1.setSid(new java.util.HashMap<String, Integer>());
72         mo1.getSid().put("test", 10);
73         FixedStruct fs = new FixedStruct();
74         fs.m = 78;
75         mo1.setFs(fs);
76         VarStruct vs = new VarStruct();
77         vs.m = "hello";
78         mo1.setVs(vs);
79 
80         mo1.setShs(new short[] { (short)1 });
81         mo1.setEs(new MyEnum[] { MyEnum.MyEnumMember, MyEnum.MyEnumMember });
82         mo1.setFss(new FixedStruct[] { fs });
83         mo1.setVss(new VarStruct[] { vs });
84         mo1.setOos(new OneOptional[] { oo1 });
85         mo1.setOops(new OneOptionalPrx[] { OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test")) });
86 
87         mo1.setIed(new java.util.HashMap<Integer, MyEnum>());
88         mo1.getIed().put(4, MyEnum.MyEnumMember);
89         mo1.setIfsd(new java.util.HashMap<Integer, FixedStruct>());
90         mo1.getIfsd().put(4, fs);
91         mo1.setIvsd(new java.util.HashMap<Integer, VarStruct>());
92         mo1.getIvsd().put(5, vs);
93         mo1.setIood(new java.util.HashMap<Integer, OneOptional>());
94         mo1.getIood().put(5, new OneOptional(15));
95         mo1.setIoopd(new java.util.HashMap<Integer, OneOptionalPrx>());
96         mo1.getIoopd().put(5, OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test")));
97 
98         mo1.setBos(new boolean[] { false, true, false });
99 
100         mo1.setSer(new SerializableClass(58));
101 
102         test(mo1.getA() == (byte)15);
103         test(mo1.getB());
104         test(mo1.isB());
105         test(mo1.getC() == (short)19);
106         test(mo1.getD() == 78);
107         test(mo1.getE() == 99);
108         test(mo1.getF() == (float)5.5);
109         test(mo1.getG() == 1.0);
110         test(mo1.getH().equals("test"));
111         test(mo1.getI() == MyEnum.MyEnumMember);
112         test(mo1.getJ().equals(MultiOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test"))));
113         test(mo1.getK() == mo1);
114         test(java.util.Arrays.equals(mo1.getBs(), new byte[] { (byte)5 }));
115         test(java.util.Arrays.equals(mo1.getSs(), new String[] { "test", "test2" }));
116         test(mo1.getIid().get(4) == 3);
117         test(mo1.getSid().get("test") == 10);
118         test(mo1.getFs().equals(new FixedStruct(78)));
119         test(mo1.getVs().equals(new VarStruct("hello")));
120 
121         test(mo1.getShs()[0] == (short)1);
122         test(mo1.getEs()[0] == MyEnum.MyEnumMember && mo1.getEs()[1] == MyEnum.MyEnumMember);
123         test(mo1.getFss()[0].equals(new FixedStruct(78)));
124         test(mo1.getVss()[0].equals(new VarStruct("hello")));
125         test(mo1.getOos()[0] == oo1);
126         test(mo1.getOops()[0].equals(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test"))));
127 
128         test(mo1.getIed().get(4) == MyEnum.MyEnumMember);
129         test(mo1.getIfsd().get(4).equals(new FixedStruct(78)));
130         test(mo1.getIvsd().get(5).equals(new VarStruct("hello")));
131         test(mo1.getIood().get(5).getA() == 15);
132         test(mo1.getIoopd().get(5).equals(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test"))));
133 
134         test(java.util.Arrays.equals(mo1.getBos(), new boolean[] { false, true, false }));
135 
136         test(mo1.getSer().equals(new SerializableClass(58)));
137 
138         out.println("ok");
139 
140         out.print("testing marshaling... ");
141         out.flush();
142 
143         OneOptional oo4 = (OneOptional)initial.pingPong(new OneOptional());
144         test(!oo4.hasA());
145 
146         OneOptional oo5 = (OneOptional)initial.pingPong(oo1);
147         test(oo1.getA() == oo5.getA());
148 
149         MultiOptional mo4 = (MultiOptional)initial.pingPong(new MultiOptional());
150         test(!mo4.hasA());
151         test(!mo4.hasB());
152         test(!mo4.hasC());
153         test(!mo4.hasD());
154         test(!mo4.hasE());
155         test(!mo4.hasF());
156         test(!mo4.hasG());
157         test(!mo4.hasH());
158         test(!mo4.hasI());
159         test(!mo4.hasJ());
160         test(!mo4.hasK());
161         test(!mo4.hasBs());
162         test(!mo4.hasSs());
163         test(!mo4.hasIid());
164         test(!mo4.hasSid());
165         test(!mo4.hasFs());
166         test(!mo4.hasVs());
167 
168         test(!mo4.hasShs());
169         test(!mo4.hasEs());
170         test(!mo4.hasFss());
171         test(!mo4.hasVss());
172         test(!mo4.hasOos());
173         test(!mo4.hasOops());
174 
175         test(!mo4.hasIed());
176         test(!mo4.hasIfsd());
177         test(!mo4.hasIvsd());
178         test(!mo4.hasIood());
179         test(!mo4.hasIoopd());
180 
181         test(!mo4.hasBos());
182 
183         test(!mo4.hasSer());
184 
185         final boolean supportsJavaSerializable = initial.supportsJavaSerializable();
186         if(!supportsJavaSerializable)
187         {
188             mo1.clearSer();
189         }
190 
191         MultiOptional mo5 = (MultiOptional)initial.pingPong(mo1);
192         test(mo5.getA() == mo1.getA());
193         test(mo5.getB() == mo1.getB());
194         test(mo5.getC() == mo1.getC());
195         test(mo5.getD() == mo1.getD());
196         test(mo5.getE() == mo1.getE());
197         test(mo5.getF() == mo1.getF());
198         test(mo5.getG() == mo1.getG());
199         test(mo5.getH().equals(mo1.getH()));
200         test(mo5.getI() == mo1.getI());
201         test(mo5.getJ().equals(mo1.getJ()));
202         test(mo5.getK() == mo5);
203         test(java.util.Arrays.equals(mo5.getBs(), mo1.getBs()));
204         test(java.util.Arrays.equals(mo5.getSs(), mo1.getSs()));
205         test(mo5.getIid().get(4) == 3);
206         test(mo5.getSid().get("test") == 10);
207         test(mo5.getFs().equals(mo1.getFs()));
208         test(mo5.getVs().equals(mo1.getVs()));
209         test(java.util.Arrays.equals(mo5.getShs(), mo1.getShs()));
210         test(mo5.getEs()[0] == MyEnum.MyEnumMember && mo1.getEs()[1] == MyEnum.MyEnumMember);
211         test(mo5.getFss()[0].equals(new FixedStruct(78)));
212         test(mo5.getVss()[0].equals(new VarStruct("hello")));
213         test(mo5.getOos()[0].getA() == 15);
214         test(mo5.getOops()[0].equals(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test"))));
215 
216         test(mo5.getIed().get(4) == MyEnum.MyEnumMember);
217         test(mo5.getIfsd().get(4).equals(new FixedStruct(78)));
218         test(mo5.getIvsd().get(5).equals(new VarStruct("hello")));
219         test(mo5.getIood().get(5).getA() == 15);
220         test(mo5.getIoopd().get(5).equals(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test"))));
221 
222         test(java.util.Arrays.equals(mo5.getBos(), new boolean[] { false, true, false }));
223 
224         if(supportsJavaSerializable)
225         {
226             test(mo5.getSer().equals(mo1.getSer()));
227         }
228 
229         // Clear the first half of the optional parameters
230         MultiOptional mo6 = new MultiOptional();
231         mo6.setB(mo5.getB());
232         mo6.setD(mo5.getD());
233         mo6.setF(mo5.getF());
234         mo6.setH(mo5.getH());
235         mo6.setJ(mo5.getJ());
236         mo6.setBs(mo5.getBs());
237         mo6.setIid(mo5.getIid());
238         mo6.setFs(mo5.getFs());
239         mo6.setShs(mo5.getShs());
240         mo6.setFss(mo5.getFss());
241         mo6.setOos(mo5.getOos());
242         mo6.setIfsd(mo5.getIfsd());
243         mo6.setIood(mo5.getIood());
244         mo6.setBos(mo5.getBos());
245 
246         MultiOptional mo7 = (MultiOptional)initial.pingPong(mo6);
247         test(!mo7.hasA());
248         test(mo7.getB() == mo1.getB());
249         test(!mo7.hasC());
250         test(mo7.getD() == mo1.getD());
251         test(!mo7.hasE());
252         test(mo7.getF() == mo1.getF());
253         test(!mo7.hasG());
254         test(mo7.getH().equals(mo1.getH()));
255         test(!mo7.hasI());
256         test(mo7.getJ().equals(mo1.getJ()));
257         test(!mo7.hasK());
258         test(java.util.Arrays.equals(mo7.getBs(), mo1.getBs()));
259         test(!mo7.hasSs());
260         test(mo7.getIid().get(4) == 3);
261         test(!mo7.hasSid());
262         test(mo7.getFs().equals(mo1.getFs()));
263         test(!mo7.hasVs());
264 
265         test(java.util.Arrays.equals(mo7.getShs(), mo1.getShs()));
266         test(!mo7.hasEs());
267         test(mo7.getFss()[0].equals(new FixedStruct(78)));
268         test(!mo7.hasVss());
269         test(mo7.getOos()[0].getA() == 15);
270         test(!mo7.hasOops());
271 
272         test(!mo7.hasIed());
273         test(mo7.getIfsd().get(4).equals(new FixedStruct(78)));
274         test(!mo7.hasIvsd());
275         test(mo7.getIood().get(5).getA() == 15);
276         test(!mo7.hasIoopd());
277 
278         test(java.util.Arrays.equals(mo7.getBos(), new boolean[] { false, true, false }));
279 
280         // Clear the second half of the optional parameters
281         MultiOptional mo8 = new MultiOptional();
282         mo8.setA(mo5.getA());
283         mo8.setC(mo5.getC());
284         mo8.setE(mo5.getE());
285         mo8.setG(mo5.getG());
286         mo8.setI(mo5.getI());
287         mo8.setK(mo8);
288         mo8.setSs(mo5.getSs());
289         mo8.setSid(mo5.getSid());
290         mo8.setVs(mo5.getVs());
291 
292         mo8.setEs(mo5.getEs());
293         mo8.setVss(mo5.getVss());
294         mo8.setOops(mo5.getOops());
295 
296         mo8.setIed(mo5.getIed());
297         mo8.setIvsd(mo5.getIvsd());
298         mo8.setIoopd(mo5.getIoopd());
299 
300         MultiOptional mo9 = (MultiOptional)initial.pingPong(mo8);
301         test(mo9.getA() == mo1.getA());
302         test(!mo9.hasB());
303         test(mo9.getC() == mo1.getC());
304         test(!mo9.hasD());
305         test(mo9.getE() == mo1.getE());
306         test(!mo9.hasF());
307         test(mo9.getG() == mo1.getG());
308         test(!mo9.hasH());
309         test(mo9.getI() == mo1.getI());
310         test(!mo9.hasJ());
311         test(mo9.getK() == mo9);
312         test(!mo9.hasBs());
313         test(java.util.Arrays.equals(mo9.getSs(), mo1.getSs()));
314         test(!mo9.hasIid());
315         test(mo9.getSid().get("test") == 10);
316         test(!mo9.hasFs());
317         test(mo9.getVs().equals(mo1.getVs()));
318 
319         test(!mo9.hasShs());
320         test(mo9.getEs()[0] == MyEnum.MyEnumMember && mo1.getEs()[1] == MyEnum.MyEnumMember);
321         test(!mo9.hasFss());
322         test(mo9.getVss()[0].equals(new VarStruct("hello")));
323         test(!mo9.hasOos());
324         test(mo9.getOops()[0].equals(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test"))));
325 
326         test(mo9.getIed().get(4) == MyEnum.MyEnumMember);
327         test(!mo9.hasIfsd());
328         test(mo9.getIvsd().get(5).equals(new VarStruct("hello")));
329         test(!mo9.hasIood());
330         test(mo9.getIoopd().get(5).equals(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test"))));
331 
332         test(!mo9.hasBos());
333 
334         {
335             OptionalWithCustom owc1 = new OptionalWithCustom();
336             java.util.ArrayList<SmallStruct> l = new java.util.ArrayList<SmallStruct>();
337             l.add(new SmallStruct((byte)5));
338             l.add(new SmallStruct((byte)6));
339             l.add(new SmallStruct((byte)7));
340             owc1.setL(l);
341             owc1.setS(new ClassVarStruct(5));
342             OptionalWithCustom owc2 = (OptionalWithCustom)initial.pingPong(owc1);
343             test(owc2.hasL());
344             test(owc2.getL().equals(l));
345             test(owc2.hasS());
346             test(owc2.getS().a == 5);
347         }
348 
349         //
350         // Send a request using blobjects. Upon receival, we don't read
351         // any of the optional members. This ensures the optional members
352         // are skipped even if the receiver knows nothing about them.
353         //
354         factory.setEnabled(true);
355         Ice.OutputStream os = new Ice.OutputStream(communicator);
356         os.startEncapsulation();
357         os.writeValue(oo1);
358         os.endEncapsulation();
359         byte[] inEncaps = os.finished();
360         Ice.ByteSeqHolder outEncaps = new Ice.ByteSeqHolder();
361         test(initial.ice_invoke("pingPong", Ice.OperationMode.Normal, inEncaps, outEncaps));
362         Ice.InputStream in = new Ice.InputStream(communicator, outEncaps.value);
363         in.startEncapsulation();
364         ReadValueCallbackI cb = new ReadValueCallbackI();
365         in.readValue(cb);
366         in.endEncapsulation();
367         test(cb.obj != null && cb.obj instanceof TestObjectReader);
368 
369         os = new Ice.OutputStream(communicator);
370         os.startEncapsulation();
371         os.writeValue(mo1);
372         os.endEncapsulation();
373         inEncaps = os.finished();
374         test(initial.ice_invoke("pingPong", Ice.OperationMode.Normal, inEncaps, outEncaps));
375         in = new Ice.InputStream(communicator, outEncaps.value);
376         in.startEncapsulation();
377         in.readValue(cb);
378         in.endEncapsulation();
379         test(cb.obj != null && cb.obj instanceof TestObjectReader);
380         factory.setEnabled(false);
381 
382         //
383         // Use the 1.0 encoding with operations whose only class parameters are optional.
384         //
385         Ice.Optional<OneOptional> oo = new Ice.Optional<OneOptional>(new OneOptional(53));
386         initial.sendOptionalClass(true, oo);
387         InitialPrx initial2 = (InitialPrx)initial.ice_encodingVersion(Ice.Util.Encoding_1_0);
388         initial2.sendOptionalClass(true, oo);
389 
390         initial.returnOptionalClass(true, oo);
391         test(oo.isSet());
392         initial2.returnOptionalClass(true, oo);
393         test(!oo.isSet());
394 
395         Recursive[] recursive1 = new Recursive[1];
396         recursive1[0] = new Recursive();
397         Recursive[] recursive2 = new Recursive[1];
398         recursive2[0] = new Recursive();
399         recursive1[0].setValue(recursive2);
400         Recursive outer = new Recursive();
401         outer.setValue(recursive1);
402         initial.pingPong(outer);
403 
404         G g = new G();
405         g.setGg1Opt(new G1("gg1Opt"));
406         g.gg2 = new G2(10);
407         g.setGg2Opt(new G2(20));
408         g.gg1 = new G1("gg1");
409         g = initial.opG(g);
410         test("gg1Opt".equals(g.getGg1Opt().a));
411         test(10 == g.gg2.a);
412         test(20 == g.getGg2Opt().a);
413         test("gg1".equals(g.gg1.a));
414 
415         initial.opVoid();
416 
417         os = new Ice.OutputStream(communicator);
418         os.startEncapsulation();
419         os.writeOptional(1, Ice.OptionalFormat.F4);
420         os.writeInt(15);
421         os.writeOptional(1, Ice.OptionalFormat.VSize);
422         os.writeString("test");
423         os.endEncapsulation();
424         inEncaps = os.finished();
425         test(initial.ice_invoke("opVoid", Ice.OperationMode.Normal, inEncaps, outEncaps));
426 
427         out.println("ok");
428 
429         out.print("testing marshaling of large containers with fixed size elements... ");
430         out.flush();
431         MultiOptional mc = new MultiOptional();
432 
433         mc.setBs(new byte[1000]);
434         mc.setShs(new short[300]);
435 
436         mc.setFss(new FixedStruct[300]);
437         for(int i = 0; i < 300; ++i)
438         {
439             mc.getFss()[i] = new FixedStruct();
440         }
441 
442         mc.setIfsd(new java.util.HashMap<Integer, FixedStruct>());
443         for(int i = 0; i < 300; ++i)
444         {
445             mc.getIfsd().put(i, new FixedStruct());
446         }
447 
448         mc = (MultiOptional)initial.pingPong(mc);
449         test(mc.getBs().length == 1000);
450         test(mc.getShs().length == 300);
451         test(mc.getFss().length == 300);
452         test(mc.getIfsd().size() == 300);
453 
454         factory.setEnabled(true);
455         os = new Ice.OutputStream(communicator);
456         os.startEncapsulation();
457         os.writeValue(mc);
458         os.endEncapsulation();
459         inEncaps = os.finished();
460         outEncaps = new Ice.ByteSeqHolder();
461         test(initial.ice_invoke("pingPong", Ice.OperationMode.Normal, inEncaps, outEncaps));
462         in = new Ice.InputStream(communicator, outEncaps.value);
463         in.startEncapsulation();
464         in.readValue(cb);
465         in.endEncapsulation();
466         test(cb.obj != null && cb.obj instanceof TestObjectReader);
467         factory.setEnabled(false);
468 
469         out.println("ok");
470 
471         out.print("testing tag marshaling... ");
472         out.flush();
473         {
474             B b = new B();
475             B b2 = (B)initial.pingPong(b);
476             test(!b2.hasMa());
477             test(!b2.hasMb());
478             test(!b2.hasMc());
479 
480             b.setMa(10);
481             b.setMb(11);
482             b.setMc(12);
483             b.setMd(13);
484 
485             b2 = (B)initial.pingPong(b);
486             test(b2.getMa() == 10);
487             test(b2.getMb() == 11);
488             test(b2.getMc() == 12);
489             test(b2.getMd() == 13);
490 
491             factory.setEnabled(true);
492             os = new Ice.OutputStream(communicator);
493             os.startEncapsulation();
494             os.writeValue(b);
495             os.endEncapsulation();
496             inEncaps = os.finished();
497             outEncaps = new Ice.ByteSeqHolder();
498             test(initial.ice_invoke("pingPong", Ice.OperationMode.Normal, inEncaps, outEncaps));
499             in = new Ice.InputStream(communicator, outEncaps.value);
500             in.startEncapsulation();
501             in.readValue(cb);
502             in.endEncapsulation();
503             test(cb.obj != null);
504             factory.setEnabled(false);
505         }
506         out.println("ok");
507 
508         out.print("testing marshalling of objects with optional objects...");
509         out.flush();
510         {
511             F f = new F();
512 
513             f.setAf(new A());
514             f.ae = f.getAf();
515 
516             F rf = (F)initial.pingPong(f);
517             test(rf.ae == rf.getAf());
518 
519             factory.setEnabled(true);
520             os = new Ice.OutputStream(communicator);
521             os.startEncapsulation();
522             os.writeValue(f);
523             os.endEncapsulation();
524             inEncaps = os.finished();
525             in = new Ice.InputStream(communicator, inEncaps);
526             in.startEncapsulation();
527             final FHolder fholder = new FHolder();
528             in.readValue(new Ice.ReadValueCallback()
529                 {
530                     @Override
531                     public void valueReady(Ice.Object obj)
532                     {
533                         fholder.value = ((FObjectReader)obj).getF();
534                     }
535                 });
536             in.endEncapsulation();
537             factory.setEnabled(false);
538             rf = fholder.value;
539             test(rf.ae != null && !rf.hasAf());
540         }
541         out.println("ok");
542 
543         out.print("testing optional with default values... ");
544         out.flush();
545         {
546             WD wd = (WD)initial.pingPong(new WD());
547             test(wd.getA() == 5);
548             test(wd.getS().equals("test"));
549             wd.clearA();
550             wd.clearS();
551             wd = (WD)initial.pingPong(wd);
552             test(!wd.hasA());
553             test(!wd.hasS());
554         }
555         out.println("ok");
556 
557         if(communicator.getProperties().getPropertyAsInt("Ice.Default.SlicedFormat") > 0)
558         {
559             out.print("testing marshaling with unknown class slices... ");
560             out.flush();
561             {
562                 C c = new C();
563                 c.ss = "test";
564                 c.setMs("testms");
565                 os = new Ice.OutputStream(communicator);
566                 os.startEncapsulation();
567                 os.writeValue(c);
568                 os.endEncapsulation();
569                 inEncaps = os.finished();
570                 factory.setEnabled(true);
571                 test(initial.ice_invoke("pingPong", Ice.OperationMode.Normal, inEncaps, outEncaps));
572                 in = new Ice.InputStream(communicator, outEncaps.value);
573                 in.startEncapsulation();
574                 in.readValue(cb);
575                 in.endEncapsulation();
576                 test(cb.obj instanceof CObjectReader);
577                 factory.setEnabled(false);
578 
579                 factory.setEnabled(true);
580                 os = new Ice.OutputStream(communicator);
581                 os.startEncapsulation();
582                 Ice.Object d = new DObjectWriter();
583                 os.writeValue(d);
584                 os.endEncapsulation();
585                 inEncaps = os.finished();
586                 test(initial.ice_invoke("pingPong", Ice.OperationMode.Normal, inEncaps, outEncaps));
587                 in = new Ice.InputStream(communicator, outEncaps.value);
588                 in.startEncapsulation();
589                 in.readValue(cb);
590                 in.endEncapsulation();
591                 test(cb.obj != null && cb.obj instanceof DObjectReader);
592                 ((DObjectReader)cb.obj).check();
593                 factory.setEnabled(false);
594             }
595             out.println("ok");
596 
597             out.print("testing optionals with unknown classes...");
598             out.flush();
599             {
600                 A a = new A();
601 
602                 os = new Ice.OutputStream(communicator);
603                 os.startEncapsulation();
604                 os.writeValue(a);
605                 os.writeOptional(1, Ice.OptionalFormat.Class);
606                 os.writeValue(new DObjectWriter());
607                 os.endEncapsulation();
608                 inEncaps = os.finished();
609                 test(initial.ice_invoke("opClassAndUnknownOptional", Ice.OperationMode.Normal, inEncaps, outEncaps));
610 
611                 in = new Ice.InputStream(communicator, outEncaps.value);
612                 in.startEncapsulation();
613                 in.endEncapsulation();
614             }
615             out.println("ok");
616         }
617 
618         out.print("testing optional parameters... ");
619         out.flush();
620         final boolean reqParams = initial.supportsRequiredParams();
621 
622         {
623 
624             Ice.ByteOptional p1 = new Ice.ByteOptional();
625             Ice.ByteOptional p3 = new Ice.ByteOptional();
626             Ice.ByteOptional p2 = initial.opByte(p1, p3);
627             test(!p2.isSet() && !p3.isSet());
628 
629             p1.set((byte)56);
630             p2 = initial.opByte(p1, p3);
631             test(p2.get() == (byte)56 && p3.get() == (byte)56);
632             Ice.AsyncResult r = initial.begin_opByte(p1);
633             p2 = initial.end_opByte(p3, r);
634             test(p2.get() == (byte)56 && p3.get() == (byte)56);
635             p2 = initial.opByte(new Ice.ByteOptional(), p3);
636             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
637 
638             if(reqParams)
639             {
640                 p2 = initial.opByteReq(p1.get(), p3);
641                 test(p2.get() == (byte)56 && p3.get() == (byte)56);
642                 r = initial.begin_opByteReq(p1.get());
643                 p2 = initial.end_opByteReq(p3, r);
644                 test(p2.get() == (byte)56 && p3.get() == (byte)56);
645 
646                 os = new Ice.OutputStream(communicator);
647                 os.startEncapsulation();
648                 os.writeOptional(2, Ice.OptionalFormat.F1);
649                 os.writeByte(p1.get());
650                 os.endEncapsulation();
651                 inEncaps = os.finished();
652                 initial.ice_invoke("opByteReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
653                 in = new Ice.InputStream(communicator, outEncaps.value);
654                 in.startEncapsulation();
655                 test(in.readOptional(1, Ice.OptionalFormat.F1));
656                 test(in.readByte() == (byte)56);
657                 test(in.readOptional(3, Ice.OptionalFormat.F1));
658                 test(in.readByte() == (byte)56);
659                 in.endEncapsulation();
660 
661                 in = new Ice.InputStream(communicator, outEncaps.value);
662                 in.startEncapsulation();
663                 in.endEncapsulation();
664             }
665         }
666 
667         {
668             Ice.BooleanOptional p1 = new Ice.BooleanOptional();
669             Ice.BooleanOptional p3 = new Ice.BooleanOptional();
670             Ice.BooleanOptional p2 = initial.opBool(p1, p3);
671             test(!p2.isSet() && !p3.isSet());
672 
673             p1.set(true);
674             p2 = initial.opBool(p1, p3);
675             test(p2.get() == true && p3.get() == true);
676             Ice.AsyncResult r = initial.begin_opBool(p1);
677             p2 = initial.end_opBool(p3, r);
678             test(p2.get() == true && p3.get() == true);
679             p2 = initial.opBool(new Ice.BooleanOptional(), p3);
680             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
681 
682             if(reqParams)
683             {
684                 p2 = initial.opBoolReq(true, p3);
685                 test(p2.get() == true && p3.get() == true);
686                 r = initial.begin_opBoolReq(true);
687                 p2 = initial.end_opBoolReq(p3, r);
688                 test(p2.get() == true && p3.get() == true);
689 
690                 os = new Ice.OutputStream(communicator);
691                 os.startEncapsulation();
692                 os.writeOptional(2, Ice.OptionalFormat.F1);
693                 os.writeBool(p1.get());
694                 os.endEncapsulation();
695                 inEncaps = os.finished();
696                 initial.ice_invoke("opBoolReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
697                 in = new Ice.InputStream(communicator, outEncaps.value);
698                 in.startEncapsulation();
699                 test(in.readOptional(1, Ice.OptionalFormat.F1));
700                 test(in.readBool() == true);
701                 test(in.readOptional(3, Ice.OptionalFormat.F1));
702                 test(in.readBool() == true);
703                 in.endEncapsulation();
704 
705                 in = new Ice.InputStream(communicator, outEncaps.value);
706                 in.startEncapsulation();
707                 in.endEncapsulation();
708             }
709         }
710 
711         {
712             Ice.ShortOptional p1 = new Ice.ShortOptional();
713             Ice.ShortOptional p3 = new Ice.ShortOptional();
714             Ice.ShortOptional p2 = initial.opShort(p1, p3);
715             test(!p2.isSet() && !p3.isSet());
716 
717             p1.set((short)56);
718             p2 = initial.opShort(p1, p3);
719             test(p2.get() == 56 && p3.get() == 56);
720             Ice.AsyncResult r = initial.begin_opShort(p1);
721             p2 = initial.end_opShort(p3, r);
722             test(p2.get() == 56 && p3.get() == 56);
723             p2 = initial.opShort(new Ice.ShortOptional(), p3);
724             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
725 
726             if(reqParams)
727             {
728                 p2 = initial.opShortReq(p1.get(), p3);
729                 test(p2.get() == 56 && p3.get() == 56);
730                 r = initial.begin_opShortReq(p1.get());
731                 p2 = initial.end_opShortReq(p3, r);
732                 test(p2.get() == 56 && p3.get() == 56);
733 
734                 os = new Ice.OutputStream(communicator);
735                 os.startEncapsulation();
736                 os.writeOptional(2, Ice.OptionalFormat.F2);
737                 os.writeShort(p1.get());
738                 os.endEncapsulation();
739                 inEncaps = os.finished();
740                 initial.ice_invoke("opShortReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
741                 in = new Ice.InputStream(communicator, outEncaps.value);
742                 in.startEncapsulation();
743                 test(in.readOptional(1, Ice.OptionalFormat.F2));
744                 test(in.readShort() == 56);
745                 test(in.readOptional(3, Ice.OptionalFormat.F2));
746                 test(in.readShort() == 56);
747                 in.endEncapsulation();
748 
749                 in = new Ice.InputStream(communicator, outEncaps.value);
750                 in.startEncapsulation();
751                 in.endEncapsulation();
752             }
753         }
754 
755         {
756             Ice.IntOptional p1 = new Ice.IntOptional();
757             Ice.IntOptional p3 = new Ice.IntOptional();
758             Ice.IntOptional p2 = initial.opInt(p1, p3);
759             test(!p2.isSet() && !p3.isSet());
760 
761             p1.set(56);
762             p2 = initial.opInt(p1, p3);
763             test(p2.get() == 56 && p3.get() == 56);
764             Ice.AsyncResult r = initial.begin_opInt(p1);
765             p2 = initial.end_opInt(p3, r);
766             test(p2.get() == 56 && p3.get() == 56);
767             p2 = initial.opInt(new Ice.IntOptional(), p3);
768             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
769 
770             if(reqParams)
771             {
772                 p2 = initial.opIntReq(p1.get(), p3);
773                 test(p2.get() == 56 && p3.get() == 56);
774                 r = initial.begin_opIntReq(p1.get());
775                 p2 = initial.end_opIntReq(p3, r);
776                 test(p2.get() == 56 && p3.get() == 56);
777 
778                 os = new Ice.OutputStream(communicator);
779                 os.startEncapsulation();
780                 os.writeOptional(2, Ice.OptionalFormat.F4);
781                 os.writeInt(p1.get());
782                 os.endEncapsulation();
783                 inEncaps = os.finished();
784                 initial.ice_invoke("opIntReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
785                 in = new Ice.InputStream(communicator, outEncaps.value);
786                 in.startEncapsulation();
787                 test(in.readOptional(1, Ice.OptionalFormat.F4));
788                 test(in.readInt() == 56);
789                 test(in.readOptional(3, Ice.OptionalFormat.F4));
790                 test(in.readInt() == 56);
791                 in.endEncapsulation();
792 
793                 in = new Ice.InputStream(communicator, outEncaps.value);
794                 in.startEncapsulation();
795                 in.endEncapsulation();
796             }
797         }
798 
799         {
800             Ice.LongOptional p1 = new Ice.LongOptional();
801             Ice.LongOptional p3 = new Ice.LongOptional();
802             Ice.LongOptional p2 = initial.opLong(p1, p3);
803             test(!p2.isSet() && !p3.isSet());
804 
805             p1.set(56);
806             p2 = initial.opLong(p1, p3);
807             test(p2.get() == 56 && p3.get() == 56);
808             Ice.AsyncResult r = initial.begin_opLong(p1);
809             p2 = initial.end_opLong(p3, r);
810             test(p2.get() == 56 && p3.get() == 56);
811             p2 = initial.opLong(new Ice.LongOptional(), p3);
812             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
813 
814             if(reqParams)
815             {
816                 p2 = initial.opLongReq(p1.get(), p3);
817                 test(p2.get() == 56 && p3.get() == 56);
818                 r = initial.begin_opLongReq(p1.get());
819                 p2 = initial.end_opLongReq(p3, r);
820                 test(p2.get() == 56 && p3.get() == 56);
821 
822                 os = new Ice.OutputStream(communicator);
823                 os.startEncapsulation();
824                 os.writeOptional(1, Ice.OptionalFormat.F8);
825                 os.writeLong(p1.get());
826                 os.endEncapsulation();
827                 inEncaps = os.finished();
828                 initial.ice_invoke("opLongReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
829                 in = new Ice.InputStream(communicator, outEncaps.value);
830                 in.startEncapsulation();
831                 test(in.readOptional(2, Ice.OptionalFormat.F8));
832                 test(in.readLong() == 56);
833                 test(in.readOptional(3, Ice.OptionalFormat.F8));
834                 test(in.readLong() == 56);
835                 in.endEncapsulation();
836 
837                 in = new Ice.InputStream(communicator, outEncaps.value);
838                 in.startEncapsulation();
839                 in.endEncapsulation();
840             }
841         }
842 
843         {
844             Ice.FloatOptional p1 = new Ice.FloatOptional();
845             Ice.FloatOptional p3 = new Ice.FloatOptional();
846             Ice.FloatOptional p2 = initial.opFloat(p1, p3);
847             test(!p2.isSet() && !p3.isSet());
848 
849             p1.set((float)1.0);
850             p2 = initial.opFloat(p1, p3);
851             test(p2.get() == 1.0 && p3.get() == 1.0);
852             Ice.AsyncResult r = initial.begin_opFloat(p1);
853             p2 = initial.end_opFloat(p3, r);
854             test(p2.get() == 1.0 && p3.get() == 1.0);
855             p2 = initial.opFloat(new Ice.FloatOptional(), p3);
856             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
857 
858             if(reqParams)
859             {
860                 p2 = initial.opFloatReq(p1.get(), p3);
861                 test(p2.get() == 1.0 && p3.get() == 1.0);
862                 r = initial.begin_opFloatReq(p1.get());
863                 p2 = initial.end_opFloatReq(p3, r);
864                 test(p2.get() == 1.0 && p3.get() == 1.0);
865 
866                 os = new Ice.OutputStream(communicator);
867                 os.startEncapsulation();
868                 os.writeOptional(2, Ice.OptionalFormat.F4);
869                 os.writeFloat(p1.get());
870                 os.endEncapsulation();
871                 inEncaps = os.finished();
872                 initial.ice_invoke("opFloatReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
873                 in = new Ice.InputStream(communicator, outEncaps.value);
874                 in.startEncapsulation();
875                 test(in.readOptional(1, Ice.OptionalFormat.F4));
876                 test(in.readFloat() == 1.0);
877                 test(in.readOptional(3, Ice.OptionalFormat.F4));
878                 test(in.readFloat() == 1.0);
879                 in.endEncapsulation();
880 
881                 in = new Ice.InputStream(communicator, outEncaps.value);
882                 in.startEncapsulation();
883                 in.endEncapsulation();
884             }
885         }
886 
887         {
888             Ice.DoubleOptional p1 = new Ice.DoubleOptional();
889             Ice.DoubleOptional p3 = new Ice.DoubleOptional();
890             Ice.DoubleOptional p2 = initial.opDouble(p1, p3);
891             test(!p2.isSet() && !p3.isSet());
892 
893             p1.set(1.0);
894             p2 = initial.opDouble(p1, p3);
895             test(p2.get() == 1.0 && p3.get() == 1.0);
896             Ice.AsyncResult r = initial.begin_opDouble(p1);
897             p2 = initial.end_opDouble(p3, r);
898             test(p2.get() == 1.0 && p3.get() == 1.0);
899             p2 = initial.opDouble(new Ice.DoubleOptional(), p3);
900             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
901 
902             if(reqParams)
903             {
904                 p2 = initial.opDoubleReq(p1.get(), p3);
905                 test(p2.get() == 1.0 && p3.get() == 1.0);
906                 r = initial.begin_opDoubleReq(p1.get());
907                 p2 = initial.end_opDoubleReq(p3, r);
908                 test(p2.get() == 1.0 && p3.get() == 1.0);
909 
910                 os = new Ice.OutputStream(communicator);
911                 os.startEncapsulation();
912                 os.writeOptional(2, Ice.OptionalFormat.F8);
913                 os.writeDouble(p1.get());
914                 os.endEncapsulation();
915                 inEncaps = os.finished();
916                 initial.ice_invoke("opDoubleReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
917                 in = new Ice.InputStream(communicator, outEncaps.value);
918                 in.startEncapsulation();
919                 test(in.readOptional(1, Ice.OptionalFormat.F8));
920                 test(in.readDouble() == 1.0);
921                 test(in.readOptional(3, Ice.OptionalFormat.F8));
922                 test(in.readDouble() == 1.0);
923                 in.endEncapsulation();
924 
925                 in = new Ice.InputStream(communicator, outEncaps.value);
926                 in.startEncapsulation();
927                 in.endEncapsulation();
928             }
929         }
930 
931         {
932             Ice.Optional<String> p1 = new Ice.Optional<String>();
933             Ice.Optional<String> p3 = new Ice.Optional<String>();
934             Ice.Optional<String> p2 = initial.opString(p1, p3);
935             test(!p2.isSet() && !p3.isSet());
936 
937             p1.set("test");
938             p2 = initial.opString(p1, p3);
939             test(p2.get().equals("test") && p3.get().equals("test"));
940             Ice.AsyncResult r = initial.begin_opString(p1);
941             p2 = initial.end_opString(p3, r);
942             test(p2.get().equals("test") && p3.get().equals("test"));
943             p2 = initial.opString(new Ice.Optional<String>(), p3);
944             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
945 
946             if(reqParams)
947             {
948                 p2 = initial.opStringReq(p1.get(), p3);
949                 test(p2.get().equals("test") && p3.get().equals("test"));
950                 r = initial.begin_opStringReq(p1.get());
951                 p2 = initial.end_opStringReq(p3, r);
952                 test(p2.get().equals("test") && p3.get().equals("test"));
953 
954                 os = new Ice.OutputStream(communicator);
955                 os.startEncapsulation();
956                 os.writeOptional(2, Ice.OptionalFormat.VSize);
957                 os.writeString(p1.get());
958                 os.endEncapsulation();
959                 inEncaps = os.finished();
960                 initial.ice_invoke("opStringReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
961                 in = new Ice.InputStream(communicator, outEncaps.value);
962                 in.startEncapsulation();
963                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
964                 test(in.readString().equals("test"));
965                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
966                 test(in.readString().equals("test"));
967                 in.endEncapsulation();
968 
969                 in = new Ice.InputStream(communicator, outEncaps.value);
970                 in.startEncapsulation();
971                 in.endEncapsulation();
972             }
973         }
974 
975         {
976             Ice.Optional<MyEnum> p1 = new Ice.Optional<MyEnum>();
977             Ice.Optional<MyEnum> p3 = new Ice.Optional<MyEnum>();
978             Ice.Optional<MyEnum> p2 = initial.opMyEnum(p1, p3);
979             test(!p2.isSet() && !p3.isSet());
980 
981             p1.set(MyEnum.MyEnumMember);
982             p2 = initial.opMyEnum(p1, p3);
983             test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
984             p1.set(MyEnum.MyEnumMember);
985             p2 = initial.opMyEnum(new Ice.Optional<MyEnum>((MyEnum)null), p3); // Test null enum
986             test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
987             Ice.AsyncResult r = initial.begin_opMyEnum(p1);
988             p2 = initial.end_opMyEnum(p3, r);
989             test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
990             p2 = initial.opMyEnum(new Ice.Optional<MyEnum>(), p3);
991             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
992 
993             if(reqParams)
994             {
995                 p2 = initial.opMyEnumReq(p1.get(), p3);
996                 test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
997                 r = initial.begin_opMyEnumReq(p1.get());
998                 p2 = initial.end_opMyEnumReq(p3, r);
999                 test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
1000 
1001                 os = new Ice.OutputStream(communicator);
1002                 os.startEncapsulation();
1003                 os.writeOptional(2, Ice.OptionalFormat.Size);
1004                 MyEnum.ice_write(os, p1.get());
1005                 os.endEncapsulation();
1006                 inEncaps = os.finished();
1007                 initial.ice_invoke("opMyEnumReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1008                 in = new Ice.InputStream(communicator, outEncaps.value);
1009                 in.startEncapsulation();
1010                 test(in.readOptional(1, Ice.OptionalFormat.Size));
1011                 test(MyEnum.ice_read(in) == MyEnum.MyEnumMember);
1012                 test(in.readOptional(3, Ice.OptionalFormat.Size));
1013                 test(MyEnum.ice_read(in) == MyEnum.MyEnumMember);
1014                 in.endEncapsulation();
1015 
1016                 in = new Ice.InputStream(communicator, outEncaps.value);
1017                 in.startEncapsulation();
1018                 in.endEncapsulation();
1019             }
1020         }
1021 
1022         {
1023             Ice.Optional<SmallStruct> p1 = new Ice.Optional<SmallStruct>();
1024             Ice.Optional<SmallStruct> p3 = new Ice.Optional<SmallStruct>();
1025             Ice.Optional<SmallStruct> p2 = initial.opSmallStruct(p1, p3);
1026             test(!p2.isSet() && !p3.isSet());
1027 
1028             p1.set(new SmallStruct((byte)56));
1029             p2 = initial.opSmallStruct(p1, p3);
1030             test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
1031             p2 = initial.opSmallStruct(new Ice.Optional<SmallStruct>((SmallStruct)null), p3); // Test null struct
1032             test(p2.get().m == (byte)0 && p3.get().m == (byte)0);
1033             Ice.AsyncResult r = initial.begin_opSmallStruct(p1);
1034             p2 = initial.end_opSmallStruct(p3, r);
1035             test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
1036             p2 = initial.opSmallStruct(new Ice.Optional<SmallStruct>(), p3);
1037             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1038 
1039             if(reqParams)
1040             {
1041                 p2 = initial.opSmallStructReq(p1.get(), p3);
1042                 test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
1043                 r = initial.begin_opSmallStructReq(p1.get());
1044                 p2 = initial.end_opSmallStructReq(p3, r);
1045                 test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
1046 
1047                 os = new Ice.OutputStream(communicator);
1048                 os.startEncapsulation();
1049                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1050                 os.writeSize(1);
1051                 SmallStruct.ice_write(os, p1.get());
1052                 os.endEncapsulation();
1053                 inEncaps = os.finished();
1054                 initial.ice_invoke("opSmallStructReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1055                 in = new Ice.InputStream(communicator, outEncaps.value);
1056                 in.startEncapsulation();
1057                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1058                 in.skipSize();
1059                 SmallStruct f = SmallStruct.ice_read(in);
1060                 test(f.m == (byte)56);
1061                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1062                 in.skipSize();
1063                 f = SmallStruct.ice_read(in);
1064                 test(f.m == (byte)56);
1065                 in.endEncapsulation();
1066 
1067                 in = new Ice.InputStream(communicator, outEncaps.value);
1068                 in.startEncapsulation();
1069                 in.endEncapsulation();
1070             }
1071         }
1072 
1073         {
1074             Ice.Optional<FixedStruct> p1 = new Ice.Optional<FixedStruct>();
1075             Ice.Optional<FixedStruct> p3 = new Ice.Optional<FixedStruct>();
1076             Ice.Optional<FixedStruct> p2 = initial.opFixedStruct(p1, p3);
1077             test(!p2.isSet() && !p3.isSet());
1078 
1079             p1.set(new FixedStruct(56));
1080             p2 = initial.opFixedStruct(p1, p3);
1081             test(p2.get().m == 56 && p3.get().m == 56);
1082             Ice.AsyncResult r = initial.begin_opFixedStruct(p1);
1083             p2 = initial.end_opFixedStruct(p3, r);
1084             test(p2.get().m == 56 && p3.get().m == 56);
1085             p2 = initial.opFixedStruct(new Ice.Optional<FixedStruct>(), p3);
1086             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1087 
1088             if(reqParams)
1089             {
1090                 p2 = initial.opFixedStructReq(p1.get(), p3);
1091                 test(p2.get().m == 56 && p3.get().m == 56);
1092                 r = initial.begin_opFixedStructReq(p1.get());
1093                 p2 = initial.end_opFixedStructReq(p3, r);
1094                 test(p2.get().m == 56 && p3.get().m == 56);
1095 
1096                 os = new Ice.OutputStream(communicator);
1097                 os.startEncapsulation();
1098                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1099                 os.writeSize(4);
1100                 FixedStruct.ice_write(os, p1.get());
1101                 os.endEncapsulation();
1102                 inEncaps = os.finished();
1103                 initial.ice_invoke("opFixedStructReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1104                 in = new Ice.InputStream(communicator, outEncaps.value);
1105                 in.startEncapsulation();
1106                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1107                 in.skipSize();
1108                 FixedStruct f = FixedStruct.ice_read(in);
1109                 test(f.m == 56);
1110                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1111                 in.skipSize();
1112                 f = FixedStruct.ice_read(in);
1113                 test(f.m == 56);
1114                 in.endEncapsulation();
1115 
1116                 in = new Ice.InputStream(communicator, outEncaps.value);
1117                 in.startEncapsulation();
1118                 in.endEncapsulation();
1119             }
1120         }
1121 
1122         {
1123             Ice.Optional<VarStruct> p1 = new Ice.Optional<VarStruct>();
1124             Ice.Optional<VarStruct> p3 = new Ice.Optional<VarStruct>();
1125             Ice.Optional<VarStruct> p2 = initial.opVarStruct(p1, p3);
1126             test(!p2.isSet() && !p3.isSet());
1127 
1128             p1.set(new VarStruct("test"));
1129             p2 = initial.opVarStruct(p1, p3);
1130             test(p2.get().m.equals("test") && p3.get().m.equals("test"));
1131             Ice.AsyncResult r = initial.begin_opVarStruct(p1);
1132             p2 = initial.end_opVarStruct(p3, r);
1133             test(p2.get().m.equals("test") && p3.get().m.equals("test"));
1134             p2 = initial.opVarStruct(new Ice.Optional<VarStruct>(), p3);
1135             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1136 
1137             if(reqParams)
1138             {
1139                 p2 = initial.opVarStructReq(p1.get(), p3);
1140                 test(p2.get().m.equals("test") && p3.get().m.equals("test"));
1141                 r = initial.begin_opVarStructReq(p1.get());
1142                 p2 = initial.end_opVarStructReq(p3, r);
1143                 test(p2.get().m.equals("test") && p3.get().m.equals("test"));
1144 
1145                 os = new Ice.OutputStream(communicator);
1146                 os.startEncapsulation();
1147                 os.writeOptional(2, Ice.OptionalFormat.FSize);
1148                 int pos = os.startSize();
1149                 VarStruct.ice_write(os, p1.get());
1150                 os.endSize(pos);
1151                 os.endEncapsulation();
1152                 inEncaps = os.finished();
1153                 initial.ice_invoke("opVarStructReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1154                 in = new Ice.InputStream(communicator, outEncaps.value);
1155                 in.startEncapsulation();
1156                 test(in.readOptional(1, Ice.OptionalFormat.FSize));
1157                 in.skip(4);
1158                 VarStruct v = VarStruct.ice_read(in);
1159                 test(v.m.equals("test"));
1160                 test(in.readOptional(3, Ice.OptionalFormat.FSize));
1161                 in.skip(4);
1162                 v = VarStruct.ice_read(in);
1163                 test(v.m.equals("test"));
1164                 in.endEncapsulation();
1165 
1166                 in = new Ice.InputStream(communicator, outEncaps.value);
1167                 in.startEncapsulation();
1168                 in.endEncapsulation();
1169             }
1170         }
1171 
1172         {
1173             Ice.Optional<OneOptional> p1 = new Ice.Optional<OneOptional>();
1174             Ice.Optional<OneOptional> p3 = new Ice.Optional<OneOptional>();
1175             Ice.Optional<OneOptional> p2 = initial.opOneOptional(p1, p3);
1176             test(!p2.isSet() && !p3.isSet());
1177 
1178             p1.set(new OneOptional(58));
1179             p2 = initial.opOneOptional(p1, p3);
1180             test(p2.get().getA() == 58 && p3.get().getA() == 58);
1181             Ice.AsyncResult r = initial.begin_opOneOptional(p1);
1182             p2 = initial.end_opOneOptional(p3, r);
1183             test(p2.get().getA() == 58 && p3.get().getA() == 58);
1184             p2 = initial.opOneOptional(new Ice.Optional<OneOptional>(), p3);
1185             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1186 
1187             if(reqParams)
1188             {
1189                 p2 = initial.opOneOptionalReq(p1.get(), p3);
1190                 test(p2.get().getA() == 58 && p3.get().getA() == 58);
1191                 r = initial.begin_opOneOptionalReq(p1.get());
1192                 p2 = initial.end_opOneOptionalReq(p3, r);
1193                 test(p2.get().getA() == 58 && p3.get().getA() == 58);
1194 
1195                 os = new Ice.OutputStream(communicator);
1196                 os.startEncapsulation();
1197                 os.writeOptional(2, Ice.OptionalFormat.Class);
1198                 os.writeValue(p1.get());
1199                 os.endEncapsulation();
1200                 inEncaps = os.finished();
1201                 initial.ice_invoke("opOneOptionalReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1202                 in = new Ice.InputStream(communicator, outEncaps.value);
1203                 in.startEncapsulation();
1204                 test(in.readOptional(1, Ice.OptionalFormat.Class));
1205                 ReadValueCallbackI p2cb = new ReadValueCallbackI();
1206                 in.readValue(p2cb);
1207                 test(in.readOptional(3, Ice.OptionalFormat.Class));
1208                 ReadValueCallbackI p3cb = new ReadValueCallbackI();
1209                 in.readValue(p3cb);
1210                 in.endEncapsulation();
1211                 test(((OneOptional)p2cb.obj).getA() == 58 && ((OneOptional)p3cb.obj).getA() == 58);
1212 
1213                 in = new Ice.InputStream(communicator, outEncaps.value);
1214                 in.startEncapsulation();
1215                 in.endEncapsulation();
1216             }
1217         }
1218 
1219         {
1220             Ice.Optional<OneOptionalPrx> p1 = new Ice.Optional<OneOptionalPrx>();
1221             Ice.Optional<OneOptionalPrx> p3 = new Ice.Optional<OneOptionalPrx>();
1222             Ice.Optional<OneOptionalPrx> p2 = initial.opOneOptionalProxy(p1, p3);
1223             test(!p2.isSet() && !p3.isSet());
1224 
1225             p1.set(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test")));
1226             p2 = initial.opOneOptionalProxy(p1, p3);
1227             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1228             Ice.AsyncResult r = initial.begin_opOneOptionalProxy(p1);
1229             p2 = initial.end_opOneOptionalProxy(p3, r);
1230             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1231             p2 = initial.opOneOptionalProxy(new Ice.Optional<OneOptionalPrx>(), p3);
1232             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1233 
1234             if(reqParams)
1235             {
1236                 p2 = initial.opOneOptionalProxyReq(p1.get(), p3);
1237                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1238                 r = initial.begin_opOneOptionalProxyReq(p1.get());
1239                 p2 = initial.end_opOneOptionalProxyReq(p3, r);
1240                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1241 
1242                 os = new Ice.OutputStream(communicator);
1243                 os.startEncapsulation();
1244                 os.writeOptional(2, Ice.OptionalFormat.FSize);
1245                 int pos = os.startSize();
1246                 os.writeProxy(p1.get());
1247                 os.endSize(pos);
1248                 os.endEncapsulation();
1249                 inEncaps = os.finished();
1250                 initial.ice_invoke("opOneOptionalProxyReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1251                 in = new Ice.InputStream(communicator, outEncaps.value);
1252                 in.startEncapsulation();
1253                 test(in.readOptional(1, Ice.OptionalFormat.FSize));
1254                 in.skip(4);
1255                 test(in.readProxy().equals(p1.get()));
1256                 test(in.readOptional(3, Ice.OptionalFormat.FSize));
1257                 in.skip(4);
1258                 test(in.readProxy().equals(p1.get()));
1259                 in.endEncapsulation();
1260 
1261                 in = new Ice.InputStream(communicator, outEncaps.value);
1262                 in.startEncapsulation();
1263                 in.endEncapsulation();
1264             }
1265         }
1266         out.println("ok");
1267 
1268         out.print("testing optional parameters and sequences... ");
1269         out.flush();
1270         {
1271             Ice.Optional<byte[]> p1 = new Ice.Optional<byte[]>();
1272             Ice.Optional<byte[]> p3 = new Ice.Optional<byte[]>();
1273             Ice.Optional<byte[]> p2 = initial.opByteSeq(p1, p3);
1274             test(!p2.isSet() && !p3.isSet());
1275 
1276             p1.set(new byte[100]);
1277             java.util.Arrays.fill(p1.get(), (byte)56);
1278             p2 = initial.opByteSeq(p1, p3);
1279             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1280             Ice.AsyncResult r = initial.begin_opByteSeq(p1);
1281             p2 = initial.end_opByteSeq(p3, r);
1282             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1283             p2 = initial.opByteSeq(new Ice.Optional<byte[]>(), p3);
1284             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1285 
1286             if(reqParams)
1287             {
1288                 p2 = initial.opByteSeqReq(p1.get(), p3);
1289                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1290                 r = initial.begin_opByteSeqReq(p1.get());
1291                 p2 = initial.end_opByteSeqReq(p3, r);
1292                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1293 
1294                 os = new Ice.OutputStream(communicator);
1295                 os.startEncapsulation();
1296                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1297                 os.writeByteSeq(p1.get());
1298                 os.endEncapsulation();
1299                 inEncaps = os.finished();
1300                 initial.ice_invoke("opByteSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1301                 in = new Ice.InputStream(communicator, outEncaps.value);
1302                 in.startEncapsulation();
1303                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1304                 test(java.util.Arrays.equals(in.readByteSeq(), p1.get()));
1305                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1306                 test(java.util.Arrays.equals(in.readByteSeq(), p1.get()));
1307                 in.endEncapsulation();
1308 
1309                 in = new Ice.InputStream(communicator, outEncaps.value);
1310                 in.startEncapsulation();
1311                 in.endEncapsulation();
1312             }
1313         }
1314 
1315         {
1316             Ice.Optional<boolean[]> p1 = new Ice.Optional<boolean[]>();
1317             Ice.Optional<boolean[]> p3 = new Ice.Optional<boolean[]>();
1318             Ice.Optional<boolean[]> p2 = initial.opBoolSeq(p1, p3);
1319             test(!p2.isSet() && !p3.isSet());
1320 
1321             p1.set(new boolean[100]);
1322             p2 = initial.opBoolSeq(p1, p3);
1323             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1324             Ice.AsyncResult r = initial.begin_opBoolSeq(p1);
1325             p2 = initial.end_opBoolSeq(p3, r);
1326             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1327             p2 = initial.opBoolSeq(new Ice.Optional<boolean[]>(), p3);
1328             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1329 
1330             if(reqParams)
1331             {
1332                 p2 = initial.opBoolSeqReq(p1.get(), p3);
1333                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1334                 r = initial.begin_opBoolSeqReq(p1.get());
1335                 p2 = initial.end_opBoolSeqReq(p3, r);
1336                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1337 
1338                 os = new Ice.OutputStream(communicator);
1339                 os.startEncapsulation();
1340                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1341                 os.writeBoolSeq(p1.get());
1342                 os.endEncapsulation();
1343                 inEncaps = os.finished();
1344                 initial.ice_invoke("opBoolSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1345                 in = new Ice.InputStream(communicator, outEncaps.value);
1346                 in.startEncapsulation();
1347                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1348                 test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
1349                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1350                 test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
1351                 in.endEncapsulation();
1352 
1353                 in = new Ice.InputStream(communicator, outEncaps.value);
1354                 in.startEncapsulation();
1355                 in.endEncapsulation();
1356             }
1357         }
1358 
1359         {
1360             Ice.Optional<short[]> p1 = new Ice.Optional<short[]>();
1361             Ice.Optional<short[]> p3 = new Ice.Optional<short[]>();
1362             Ice.Optional<short[]> p2 = initial.opShortSeq(p1, p3);
1363             test(!p2.isSet() && !p3.isSet());
1364 
1365             p1.set(new short[100]);
1366             java.util.Arrays.fill(p1.get(), (short)56);
1367             p2 = initial.opShortSeq(p1, p3);
1368             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1369             Ice.AsyncResult r = initial.begin_opShortSeq(p1);
1370             p2 = initial.end_opShortSeq(p3, r);
1371             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1372             p2 = initial.opShortSeq(new Ice.Optional<short[]>(), p3);
1373             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1374 
1375             if(reqParams)
1376             {
1377                 p2 = initial.opShortSeqReq(p1.get(), p3);
1378                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1379                 r = initial.begin_opShortSeqReq(p1.get());
1380                 p2 = initial.end_opShortSeqReq(p3, r);
1381                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1382 
1383                 os = new Ice.OutputStream(communicator);
1384                 os.startEncapsulation();
1385                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1386                 os.writeSize(p1.get().length * 2 + (p1.get().length > 254 ? 5 : 1));
1387                 os.writeShortSeq(p1.get());
1388                 os.endEncapsulation();
1389                 inEncaps = os.finished();
1390                 initial.ice_invoke("opShortSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1391                 in = new Ice.InputStream(communicator, outEncaps.value);
1392                 in.startEncapsulation();
1393                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1394                 in.skipSize();
1395                 test(java.util.Arrays.equals(in.readShortSeq(), p1.get()));
1396                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1397                 in.skipSize();
1398                 test(java.util.Arrays.equals(in.readShortSeq(), p1.get()));
1399                 in.endEncapsulation();
1400 
1401                 in = new Ice.InputStream(communicator, outEncaps.value);
1402                 in.startEncapsulation();
1403                 in.endEncapsulation();
1404             }
1405         }
1406 
1407         {
1408             Ice.Optional<int[]> p1 = new Ice.Optional<int[]>();
1409             Ice.Optional<int[]> p3 = new Ice.Optional<int[]>();
1410             Ice.Optional<int[]> p2 = initial.opIntSeq(p1, p3);
1411             test(!p2.isSet() && !p3.isSet());
1412 
1413             p1.set(new int[100]);
1414             java.util.Arrays.fill(p1.get(), 56);
1415             p2 = initial.opIntSeq(p1, p3);
1416             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1417             Ice.AsyncResult r = initial.begin_opIntSeq(p1);
1418             p2 = initial.end_opIntSeq(p3, r);
1419             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1420             p2 = initial.opIntSeq(new Ice.Optional<int[]>(), p3);
1421             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1422 
1423             if(reqParams)
1424             {
1425                 p2 = initial.opIntSeqReq(p1.get(), p3);
1426                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1427                 r = initial.begin_opIntSeqReq(p1.get());
1428                 p2 = initial.end_opIntSeqReq(p3, r);
1429                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1430 
1431                 os = new Ice.OutputStream(communicator);
1432                 os.startEncapsulation();
1433                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1434                 os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
1435                 os.writeIntSeq(p1.get());
1436                 os.endEncapsulation();
1437                 inEncaps = os.finished();
1438                 initial.ice_invoke("opIntSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1439                 in = new Ice.InputStream(communicator, outEncaps.value);
1440                 in.startEncapsulation();
1441                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1442                 in.skipSize();
1443                 test(java.util.Arrays.equals(in.readIntSeq(), p1.get()));
1444                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1445                 in.skipSize();
1446                 test(java.util.Arrays.equals(in.readIntSeq(), p1.get()));
1447                 in.endEncapsulation();
1448 
1449                 in = new Ice.InputStream(communicator, outEncaps.value);
1450                 in.startEncapsulation();
1451                 in.endEncapsulation();
1452             }
1453         }
1454 
1455         {
1456             Ice.Optional<long[]> p1 = new Ice.Optional<long[]>();
1457             Ice.Optional<long[]> p3 = new Ice.Optional<long[]>();
1458             Ice.Optional<long[]> p2 = initial.opLongSeq(p1, p3);
1459             test(!p2.isSet() && !p3.isSet());
1460 
1461             p1.set(new long[100]);
1462             java.util.Arrays.fill(p1.get(), 56);
1463             p2 = initial.opLongSeq(p1, p3);
1464             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1465             Ice.AsyncResult r = initial.begin_opLongSeq(p1);
1466             p2 = initial.end_opLongSeq(p3, r);
1467             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1468             p2 = initial.opLongSeq(new Ice.Optional<long[]>(), p3);
1469             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1470 
1471             if(reqParams)
1472             {
1473                 p2 = initial.opLongSeqReq(p1.get(), p3);
1474                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1475                 r = initial.begin_opLongSeqReq(p1.get());
1476                 p2 = initial.end_opLongSeqReq(p3, r);
1477                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1478 
1479                 os = new Ice.OutputStream(communicator);
1480                 os.startEncapsulation();
1481                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1482                 os.writeSize(p1.get().length * 8 + (p1.get().length > 254 ? 5 : 1));
1483                 os.writeLongSeq(p1.get());
1484                 os.endEncapsulation();
1485                 inEncaps = os.finished();
1486                 initial.ice_invoke("opLongSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1487                 in = new Ice.InputStream(communicator, outEncaps.value);
1488                 in.startEncapsulation();
1489                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1490                 in.skipSize();
1491                 test(java.util.Arrays.equals(in.readLongSeq(), p1.get()));
1492                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1493                 in.skipSize();
1494                 test(java.util.Arrays.equals(in.readLongSeq(), p1.get()));
1495                 in.endEncapsulation();
1496 
1497                 in = new Ice.InputStream(communicator, outEncaps.value);
1498                 in.startEncapsulation();
1499                 in.endEncapsulation();
1500             }
1501         }
1502 
1503         {
1504             Ice.Optional<float[]> p1 = new Ice.Optional<float[]>();
1505             Ice.Optional<float[]> p3 = new Ice.Optional<float[]>();
1506             Ice.Optional<float[]> p2 = initial.opFloatSeq(p1, p3);
1507             test(!p2.isSet() && !p3.isSet());
1508 
1509             p1.set(new float[100]);
1510             java.util.Arrays.fill(p1.get(), (float)1.0);
1511             p2 = initial.opFloatSeq(p1, p3);
1512             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1513             Ice.AsyncResult r = initial.begin_opFloatSeq(p1);
1514             p2 = initial.end_opFloatSeq(p3, r);
1515             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1516             p2 = initial.opFloatSeq(new Ice.Optional<float[]>(), p3);
1517             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1518 
1519             if(reqParams)
1520             {
1521                 p2 = initial.opFloatSeqReq(p1.get(), p3);
1522                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1523                 r = initial.begin_opFloatSeqReq(p1.get());
1524                 p2 = initial.end_opFloatSeqReq(p3, r);
1525                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1526 
1527                 os = new Ice.OutputStream(communicator);
1528                 os.startEncapsulation();
1529                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1530                 os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
1531                 os.writeFloatSeq(p1.get());
1532                 os.endEncapsulation();
1533                 inEncaps = os.finished();
1534                 initial.ice_invoke("opFloatSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1535                 in = new Ice.InputStream(communicator, outEncaps.value);
1536                 in.startEncapsulation();
1537                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1538                 in.skipSize();
1539                 test(java.util.Arrays.equals(in.readFloatSeq(), p1.get()));
1540                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1541                 in.skipSize();
1542                 test(java.util.Arrays.equals(in.readFloatSeq(), p1.get()));
1543                 in.endEncapsulation();
1544 
1545                 in = new Ice.InputStream(communicator, outEncaps.value);
1546                 in.startEncapsulation();
1547                 in.endEncapsulation();
1548             }
1549         }
1550 
1551         {
1552             Ice.Optional<double[]> p1 = new Ice.Optional<double[]>();
1553             Ice.Optional<double[]> p3 = new Ice.Optional<double[]>();
1554             Ice.Optional<double[]> p2 = initial.opDoubleSeq(p1, p3);
1555             test(!p2.isSet() && !p3.isSet());
1556 
1557             p1.set(new double[100]);
1558             java.util.Arrays.fill(p1.get(), 1.0);
1559             p2 = initial.opDoubleSeq(p1, p3);
1560             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1561             Ice.AsyncResult r = initial.begin_opDoubleSeq(p1);
1562             p2 = initial.end_opDoubleSeq(p3, r);
1563             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1564             p2 = initial.opDoubleSeq(new Ice.Optional<double[]>(), p3);
1565             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1566 
1567             if(reqParams)
1568             {
1569                 p2 = initial.opDoubleSeqReq(p1.get(), p3);
1570                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1571                 r = initial.begin_opDoubleSeqReq(p1.get());
1572                 p2 = initial.end_opDoubleSeqReq(p3, r);
1573                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1574 
1575                 os = new Ice.OutputStream(communicator);
1576                 os.startEncapsulation();
1577                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1578                 os.writeSize(p1.get().length * 8 + (p1.get().length > 254 ? 5 : 1));
1579                 os.writeDoubleSeq(p1.get());
1580                 os.endEncapsulation();
1581                 inEncaps = os.finished();
1582                 initial.ice_invoke("opDoubleSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1583                 in = new Ice.InputStream(communicator, outEncaps.value);
1584                 in.startEncapsulation();
1585                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1586                 in.skipSize();
1587                 test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
1588                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1589                 in.skipSize();
1590                 test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
1591                 in.endEncapsulation();
1592 
1593                 in = new Ice.InputStream(communicator, outEncaps.value);
1594                 in.startEncapsulation();
1595                 in.endEncapsulation();
1596             }
1597         }
1598 
1599         {
1600             Ice.Optional<String[]> p1 = new Ice.Optional<String[]>();
1601             Ice.Optional<String[]> p3 = new Ice.Optional<String[]>();
1602             Ice.Optional<String[]> p2 = initial.opStringSeq(p1, p3);
1603             test(!p2.isSet() && !p3.isSet());
1604 
1605             p1.set(new String[10]);
1606             java.util.Arrays.fill(p1.get(), "test1");
1607             p2 = initial.opStringSeq(p1, p3);
1608             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1609             Ice.AsyncResult r = initial.begin_opStringSeq(p1);
1610             p2 = initial.end_opStringSeq(p3, r);
1611             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1612             p2 = initial.opStringSeq(new Ice.Optional<String[]>(), p3);
1613             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1614 
1615             if(reqParams)
1616             {
1617                 p2 = initial.opStringSeqReq(p1.get(), p3);
1618                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1619                 r = initial.begin_opStringSeqReq(p1.get());
1620                 p2 = initial.end_opStringSeqReq(p3, r);
1621                 test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
1622 
1623                 os = new Ice.OutputStream(communicator);
1624                 os.startEncapsulation();
1625                 os.writeOptional(2, Ice.OptionalFormat.FSize);
1626                 int pos = os.startSize();
1627                 os.writeStringSeq(p1.get());
1628                 os.endSize(pos);
1629                 os.endEncapsulation();
1630                 inEncaps = os.finished();
1631                 initial.ice_invoke("opStringSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1632                 in = new Ice.InputStream(communicator, outEncaps.value);
1633                 in.startEncapsulation();
1634                 test(in.readOptional(1, Ice.OptionalFormat.FSize));
1635                 in.skip(4);
1636                 test(java.util.Arrays.equals(in.readStringSeq(), p1.get()));
1637                 test(in.readOptional(3, Ice.OptionalFormat.FSize));
1638                 in.skip(4);
1639                 test(java.util.Arrays.equals(in.readStringSeq(), p1.get()));
1640                 in.endEncapsulation();
1641 
1642                 in = new Ice.InputStream(communicator, outEncaps.value);
1643                 in.startEncapsulation();
1644                 in.endEncapsulation();
1645             }
1646         }
1647 
1648         {
1649             Ice.Optional<SmallStruct[]> p1 = new Ice.Optional<SmallStruct[]>();
1650             Ice.Optional<SmallStruct[]> p3 = new Ice.Optional<SmallStruct[]>();
1651             Ice.Optional<SmallStruct[]> p2 = initial.opSmallStructSeq(p1, p3);
1652             test(!p2.isSet() && !p3.isSet());
1653 
1654             p1.set(new SmallStruct[10]);
1655             for(int i = 0; i < p1.get().length; ++i)
1656             {
1657                 p1.get()[i] = new SmallStruct();
1658             }
1659             p2 = initial.opSmallStructSeq(p1, p3);
1660             for(int i = 0; i < p1.get().length; ++i)
1661             {
1662                 test(p2.get()[i].equals(p1.get()[i]));
1663             }
1664             Ice.AsyncResult r = initial.begin_opSmallStructSeq(p1);
1665             p2 = initial.end_opSmallStructSeq(p3, r);
1666             for(int i = 0; i < p1.get().length; ++i)
1667             {
1668                 test(p2.get()[i].equals(p1.get()[i]));
1669             }
1670             p2 = initial.opSmallStructSeq(new Ice.Optional<SmallStruct[]>(), p3);
1671             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1672 
1673             if(reqParams)
1674             {
1675                 p2 = initial.opSmallStructSeqReq(p1.get(), p3);
1676                 for(int i = 0; i < p1.get().length; ++i)
1677                 {
1678                     test(p2.get()[i].equals(p1.get()[i]));
1679                 }
1680                 r = initial.begin_opSmallStructSeqReq(p1.get());
1681                 p2 = initial.end_opSmallStructSeqReq(p3, r);
1682                 for(int i = 0; i < p1.get().length; ++i)
1683                 {
1684                     test(p2.get()[i].equals(p1.get()[i]));
1685                 }
1686 
1687                 os = new Ice.OutputStream(communicator);
1688                 os.startEncapsulation();
1689                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1690                 os.writeSize(p1.get().length + (p1.get().length > 254 ? 5 : 1));
1691                 SmallStructSeqHelper.write(os, p1.get());
1692                 os.endEncapsulation();
1693                 inEncaps = os.finished();
1694                 initial.ice_invoke("opSmallStructSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1695                 in = new Ice.InputStream(communicator, outEncaps.value);
1696                 in.startEncapsulation();
1697                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1698                 in.skipSize();
1699                 SmallStruct[] arr = SmallStructSeqHelper.read(in);
1700                 for(int i = 0; i < p1.get().length; ++i)
1701                 {
1702                     test(arr[i].equals(p1.get()[i]));
1703                 }
1704                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1705                 in.skipSize();
1706                 arr = SmallStructSeqHelper.read(in);
1707                 for(int i = 0; i < p1.get().length; ++i)
1708                 {
1709                     test(arr[i].equals(p1.get()[i]));
1710                 }
1711                 in.endEncapsulation();
1712 
1713                 in = new Ice.InputStream(communicator, outEncaps.value);
1714                 in.startEncapsulation();
1715                 in.endEncapsulation();
1716             }
1717         }
1718 
1719         {
1720             Ice.Optional<java.util.List<SmallStruct>> p1 = new Ice.Optional<java.util.List<SmallStruct>>();
1721             Ice.Optional<java.util.List<SmallStruct>> p3 = new Ice.Optional<java.util.List<SmallStruct>>();
1722             Ice.Optional<java.util.List<SmallStruct>> p2 = initial.opSmallStructList(p1, p3);
1723             test(!p2.isSet() && !p3.isSet());
1724 
1725             p1.set(new java.util.ArrayList<SmallStruct>());
1726             for(int i = 0; i < 10; ++i)
1727             {
1728                 p1.get().add(new SmallStruct());
1729             }
1730             p2 = initial.opSmallStructList(p1, p3);
1731             test(p2.get().equals(p1.get()));
1732             Ice.AsyncResult r = initial.begin_opSmallStructList(p1);
1733             p2 = initial.end_opSmallStructList(p3, r);
1734             test(p2.get().equals(p1.get()));
1735             p2 = initial.opSmallStructList(new Ice.Optional<java.util.List<SmallStruct>>(), p3);
1736             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1737 
1738             if(reqParams)
1739             {
1740                 p2 = initial.opSmallStructListReq(p1.get(), p3);
1741                 test(p2.get().equals(p1.get()));
1742                 r = initial.begin_opSmallStructListReq(p1.get());
1743                 p2 = initial.end_opSmallStructListReq(p3, r);
1744                 test(p2.get().equals(p1.get()));
1745 
1746                 os = new Ice.OutputStream(communicator);
1747                 os.startEncapsulation();
1748                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1749                 os.writeSize(p1.get().size() + (p1.get().size() > 254 ? 5 : 1));
1750                 SmallStructListHelper.write(os, p1.get());
1751                 os.endEncapsulation();
1752                 inEncaps = os.finished();
1753                 initial.ice_invoke("opSmallStructListReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1754                 in = new Ice.InputStream(communicator, outEncaps.value);
1755                 in.startEncapsulation();
1756                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1757                 in.skipSize();
1758                 java.util.List<SmallStruct> arr = SmallStructListHelper.read(in);
1759                 test(arr.equals(p1.get()));
1760                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1761                 in.skipSize();
1762                 arr = SmallStructListHelper.read(in);
1763                 test(arr.equals(p1.get()));
1764                 in.endEncapsulation();
1765 
1766                 in = new Ice.InputStream(communicator, outEncaps.value);
1767                 in.startEncapsulation();
1768                 in.endEncapsulation();
1769             }
1770         }
1771 
1772         {
1773             Ice.Optional<FixedStruct[]> p1 = new Ice.Optional<FixedStruct[]>();
1774             Ice.Optional<FixedStruct[]> p3 = new Ice.Optional<FixedStruct[]>();
1775             Ice.Optional<FixedStruct[]> p2 = initial.opFixedStructSeq(p1, p3);
1776             test(!p2.isSet() && !p3.isSet());
1777 
1778             p1.set(new FixedStruct[10]);
1779             for(int i = 0; i < p1.get().length; ++i)
1780             {
1781                 p1.get()[i] = new FixedStruct();
1782             }
1783             p2 = initial.opFixedStructSeq(p1, p3);
1784             for(int i = 0; i < p1.get().length; ++i)
1785             {
1786                 test(p2.get()[i].equals(p1.get()[i]));
1787             }
1788             Ice.AsyncResult r = initial.begin_opFixedStructSeq(p1);
1789             p2 = initial.end_opFixedStructSeq(p3, r);
1790             for(int i = 0; i < p1.get().length; ++i)
1791             {
1792                 test(p2.get()[i].equals(p1.get()[i]));
1793             }
1794             p2 = initial.opFixedStructSeq(new Ice.Optional<FixedStruct[]>(), p3);
1795             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1796 
1797             if(reqParams)
1798             {
1799                 p2 = initial.opFixedStructSeqReq(p1.get(), p3);
1800                 for(int i = 0; i < p1.get().length; ++i)
1801                 {
1802                     test(p2.get()[i].equals(p1.get()[i]));
1803                 }
1804                 r = initial.begin_opFixedStructSeqReq(p1.get());
1805                 p2 = initial.end_opFixedStructSeqReq(p3, r);
1806                 for(int i = 0; i < p1.get().length; ++i)
1807                 {
1808                     test(p2.get()[i].equals(p1.get()[i]));
1809                 }
1810 
1811                 os = new Ice.OutputStream(communicator);
1812                 os.startEncapsulation();
1813                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1814                 os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
1815                 FixedStructSeqHelper.write(os, p1.get());
1816                 os.endEncapsulation();
1817                 inEncaps = os.finished();
1818                 initial.ice_invoke("opFixedStructSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1819                 in = new Ice.InputStream(communicator, outEncaps.value);
1820                 in.startEncapsulation();
1821                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1822                 in.skipSize();
1823                 FixedStruct[] arr = FixedStructSeqHelper.read(in);
1824                 for(int i = 0; i < p1.get().length; ++i)
1825                 {
1826                     test(arr[i].equals(p1.get()[i]));
1827                 }
1828                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1829                 in.skipSize();
1830                 arr = FixedStructSeqHelper.read(in);
1831                 for(int i = 0; i < p1.get().length; ++i)
1832                 {
1833                     test(arr[i].equals(p1.get()[i]));
1834                 }
1835                 in.endEncapsulation();
1836 
1837                 in = new Ice.InputStream(communicator, outEncaps.value);
1838                 in.startEncapsulation();
1839                 in.endEncapsulation();
1840             }
1841         }
1842 
1843         {
1844             Ice.Optional<java.util.List<FixedStruct>> p1 = new Ice.Optional<java.util.List<FixedStruct>>();
1845             Ice.Optional<java.util.List<FixedStruct>> p3 = new Ice.Optional<java.util.List<FixedStruct>>();
1846             Ice.Optional<java.util.List<FixedStruct>> p2 = initial.opFixedStructList(p1, p3);
1847             test(!p2.isSet() && !p3.isSet());
1848 
1849             p1.set(new java.util.ArrayList<FixedStruct>());
1850             for(int i = 0; i < 10; ++i)
1851             {
1852                 p1.get().add(new FixedStruct());
1853             }
1854             p2 = initial.opFixedStructList(p1, p3);
1855             test(p2.get().equals(p1.get()));
1856             Ice.AsyncResult r = initial.begin_opFixedStructList(p1);
1857             p2 = initial.end_opFixedStructList(p3, r);
1858             test(p2.get().equals(p1.get()));
1859             p2 = initial.opFixedStructList(new Ice.Optional<java.util.List<FixedStruct>>(), p3);
1860             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1861 
1862             if(reqParams)
1863             {
1864                 p2 = initial.opFixedStructListReq(p1.get(), p3);
1865                 test(p2.get().equals(p1.get()));
1866                 r = initial.begin_opFixedStructListReq(p1.get());
1867                 p2 = initial.end_opFixedStructListReq(p3, r);
1868                 test(p2.get().equals(p1.get()));
1869 
1870                 os = new Ice.OutputStream(communicator);
1871                 os.startEncapsulation();
1872                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1873                 os.writeSize(p1.get().size() * 4 + (p1.get().size() > 254 ? 5 : 1));
1874                 FixedStructListHelper.write(os, p1.get());
1875                 os.endEncapsulation();
1876                 inEncaps = os.finished();
1877                 initial.ice_invoke("opFixedStructListReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1878                 in = new Ice.InputStream(communicator, outEncaps.value);
1879                 in.startEncapsulation();
1880                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
1881                 in.skipSize();
1882                 java.util.List<FixedStruct> arr = FixedStructListHelper.read(in);
1883                 test(arr.equals(p1.get()));
1884                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
1885                 in.skipSize();
1886                 arr = FixedStructListHelper.read(in);
1887                 test(arr.equals(p1.get()));
1888                 in.endEncapsulation();
1889 
1890                 in = new Ice.InputStream(communicator, outEncaps.value);
1891                 in.startEncapsulation();
1892                 in.endEncapsulation();
1893             }
1894         }
1895 
1896         {
1897             Ice.Optional<VarStruct[]> p1 = new Ice.Optional<VarStruct[]>();
1898             Ice.Optional<VarStruct[]> p3 = new Ice.Optional<VarStruct[]>();
1899             Ice.Optional<VarStruct[]> p2 = initial.opVarStructSeq(p1, p3);
1900             test(!p2.isSet() && !p3.isSet());
1901 
1902             p1.set(new VarStruct[10]);
1903             for(int i = 0; i < p1.get().length; ++i)
1904             {
1905                 p1.get()[i] = new VarStruct("");
1906             }
1907             p2 = initial.opVarStructSeq(p1, p3);
1908             for(int i = 0; i < p1.get().length; ++i)
1909             {
1910                 test(p2.get()[i].equals(p1.get()[i]));
1911             }
1912             Ice.AsyncResult r = initial.begin_opVarStructSeq(p1);
1913             p2 = initial.end_opVarStructSeq(p3, r);
1914             for(int i = 0; i < p1.get().length; ++i)
1915             {
1916                 test(p2.get()[i].equals(p1.get()[i]));
1917             }
1918             p2 = initial.opVarStructSeq(new Ice.Optional<VarStruct[]>(), p3);
1919             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1920 
1921             if(reqParams)
1922             {
1923                 p2 = initial.opVarStructSeqReq(p1.get(), p3);
1924                 for(int i = 0; i < p1.get().length; ++i)
1925                 {
1926                     test(p2.get()[i].equals(p1.get()[i]));
1927                 }
1928                 r = initial.begin_opVarStructSeqReq(p1.get());
1929                 p2 = initial.end_opVarStructSeqReq(p3, r);
1930                 for(int i = 0; i < p1.get().length; ++i)
1931                 {
1932                     test(p2.get()[i].equals(p1.get()[i]));
1933                 }
1934 
1935                 os = new Ice.OutputStream(communicator);
1936                 os.startEncapsulation();
1937                 os.writeOptional(2, Ice.OptionalFormat.FSize);
1938                 int pos = os.startSize();
1939                 VarStructSeqHelper.write(os, p1.get());
1940                 os.endSize(pos);
1941                 os.endEncapsulation();
1942                 inEncaps = os.finished();
1943                 initial.ice_invoke("opVarStructSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1944                 in = new Ice.InputStream(communicator, outEncaps.value);
1945                 in.startEncapsulation();
1946                 test(in.readOptional(1, Ice.OptionalFormat.FSize));
1947                 in.skip(4);
1948                 VarStruct[] arr = VarStructSeqHelper.read(in);
1949                 for(int i = 0; i < p1.get().length; ++i)
1950                 {
1951                     test(arr[i].equals(p1.get()[i]));
1952                 }
1953                 test(in.readOptional(3, Ice.OptionalFormat.FSize));
1954                 in.skip(4);
1955                 arr = VarStructSeqHelper.read(in);
1956                 for(int i = 0; i < p1.get().length; ++i)
1957                 {
1958                     test(arr[i].equals(p1.get()[i]));
1959                 }
1960                 in.endEncapsulation();
1961 
1962                 in = new Ice.InputStream(communicator, outEncaps.value);
1963                 in.startEncapsulation();
1964                 in.endEncapsulation();
1965             }
1966         }
1967 
1968         if(supportsJavaSerializable)
1969         {
1970             Ice.Optional<SerializableClass> p1 = new Ice.Optional<SerializableClass>();
1971             Ice.Optional<SerializableClass> p3 = new Ice.Optional<SerializableClass>();
1972             Ice.Optional<SerializableClass> p2 = initial.opSerializable(p1, p3);
1973             test(!p2.isSet() && !p3.isSet());
1974 
1975             p1.set(new SerializableClass(58));
1976             p2 = initial.opSerializable(p1, p3);
1977             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1978             Ice.AsyncResult r = initial.begin_opSerializable(p1);
1979             p2 = initial.end_opSerializable(p3, r);
1980             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1981             p2 = initial.opSerializable(new Ice.Optional<SerializableClass>(), p3);
1982             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
1983 
1984             if(reqParams)
1985             {
1986                 p2 = initial.opSerializableReq(p1.get(), p3);
1987                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1988                 r = initial.begin_opSerializableReq(p1.get());
1989                 p2 = initial.end_opSerializableReq(p3, r);
1990                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
1991 
1992                 os = new Ice.OutputStream(communicator);
1993                 os.startEncapsulation();
1994                 os.writeOptional(2, Ice.OptionalFormat.VSize);
1995                 os.writeSerializable(p1.get());
1996                 os.endEncapsulation();
1997                 inEncaps = os.finished();
1998                 initial.ice_invoke("opSerializableReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
1999                 in = new Ice.InputStream(communicator, outEncaps.value);
2000                 in.startEncapsulation();
2001                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
2002                 SerializableClass sc = SerializableHelper.read(in);
2003                 test(sc.equals(p1.get()));
2004                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
2005                 sc = SerializableHelper.read(in);
2006                 test(sc.equals(p1.get()));
2007                 in.endEncapsulation();
2008 
2009                 in = new Ice.InputStream(communicator, outEncaps.value);
2010                 in.startEncapsulation();
2011                 in.endEncapsulation();
2012             }
2013         }
2014         out.println("ok");
2015 
2016         out.print("testing optional parameters and dictionaries... ");
2017         out.flush();
2018         {
2019             Ice.Optional<java.util.Map<Integer, Integer>> p1 = new Ice.Optional<java.util.Map<Integer, Integer>>();
2020             Ice.Optional<java.util.Map<Integer, Integer>> p3 = new Ice.Optional<java.util.Map<Integer, Integer>>();
2021             Ice.Optional<java.util.Map<Integer, Integer>> p2 = initial.opIntIntDict(p1, p3);
2022             test(!p2.isSet() && !p3.isSet());
2023 
2024             p1.set(new java.util.HashMap<Integer, Integer>());
2025             p1.get().put(1, 2);
2026             p1.get().put(2, 3);
2027             p2 = initial.opIntIntDict(p1, p3);
2028             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2029             Ice.AsyncResult r = initial.begin_opIntIntDict(p1);
2030             p2 = initial.end_opIntIntDict(p3, r);
2031             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2032             p2 = initial.opIntIntDict(new Ice.Optional<java.util.Map<Integer, Integer>>(), p3);
2033             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
2034 
2035             if(reqParams)
2036             {
2037                 p2 = initial.opIntIntDictReq(p1.get(), p3);
2038                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2039                 r = initial.begin_opIntIntDictReq(p1.get());
2040                 p2 = initial.end_opIntIntDictReq(p3, r);
2041                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2042 
2043                 os = new Ice.OutputStream(communicator);
2044                 os.startEncapsulation();
2045                 os.writeOptional(2, Ice.OptionalFormat.VSize);
2046                 os.writeSize(p1.get().size() * 8 + (p1.get().size() > 254 ? 5 : 1));
2047                 IntIntDictHelper.write(os, p1.get());
2048                 os.endEncapsulation();
2049                 inEncaps = os.finished();
2050                 initial.ice_invoke("opIntIntDictReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
2051                 in = new Ice.InputStream(communicator, outEncaps.value);
2052                 in.startEncapsulation();
2053                 test(in.readOptional(1, Ice.OptionalFormat.VSize));
2054                 in.skipSize();
2055                 java.util.Map<Integer, Integer> m = IntIntDictHelper.read(in);
2056                 test(m.equals(p1.get()));
2057                 test(in.readOptional(3, Ice.OptionalFormat.VSize));
2058                 in.skipSize();
2059                 m = IntIntDictHelper.read(in);
2060                 test(m.equals(p1.get()));
2061                 in.endEncapsulation();
2062 
2063                 in = new Ice.InputStream(communicator, outEncaps.value);
2064                 in.startEncapsulation();
2065                 in.endEncapsulation();
2066             }
2067         }
2068 
2069         {
2070             Ice.Optional<java.util.Map<String, Integer>> p1 = new Ice.Optional<java.util.Map<String, Integer>>();
2071             Ice.Optional<java.util.Map<String, Integer>> p3 = new Ice.Optional<java.util.Map<String, Integer>>();
2072             Ice.Optional<java.util.Map<String, Integer>> p2 = initial.opStringIntDict(p1, p3);
2073             test(!p2.isSet() && !p3.isSet());
2074 
2075             p1.set(new java.util.HashMap<String, Integer>());
2076             p1.get().put("1", 1);
2077             p1.get().put("2", 2);
2078             p2 = initial.opStringIntDict(p1, p3);
2079             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2080             Ice.AsyncResult r = initial.begin_opStringIntDict(p1);
2081             p2 = initial.end_opStringIntDict(p3, r);
2082             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2083             p2 = initial.opStringIntDict(new Ice.Optional<java.util.Map<String, Integer>>(), p3);
2084             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
2085 
2086             if(reqParams)
2087             {
2088                 p2 = initial.opStringIntDictReq(p1.get(), p3);
2089                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2090                 r = initial.begin_opStringIntDictReq(p1.get());
2091                 p2 = initial.end_opStringIntDictReq(p3, r);
2092                 test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
2093 
2094                 os = new Ice.OutputStream(communicator);
2095                 os.startEncapsulation();
2096                 os.writeOptional(2, Ice.OptionalFormat.FSize);
2097                 int pos = os.startSize();
2098                 StringIntDictHelper.write(os, p1.get());
2099                 os.endSize(pos);
2100                 os.endEncapsulation();
2101                 inEncaps = os.finished();
2102                 initial.ice_invoke("opStringIntDictReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
2103                 in = new Ice.InputStream(communicator, outEncaps.value);
2104                 in.startEncapsulation();
2105                 test(in.readOptional(1, Ice.OptionalFormat.FSize));
2106                 in.skip(4);
2107                 java.util.Map<String, Integer> m = StringIntDictHelper.read(in);
2108                 test(m.equals(p1.get()));
2109                 test(in.readOptional(3, Ice.OptionalFormat.FSize));
2110                 in.skip(4);
2111                 m = StringIntDictHelper.read(in);
2112                 test(m.equals(p1.get()));
2113                 in.endEncapsulation();
2114 
2115                 in = new Ice.InputStream(communicator, outEncaps.value);
2116                 in.startEncapsulation();
2117                 in.endEncapsulation();
2118             }
2119         }
2120 
2121         {
2122             Ice.Optional<java.util.Map<Integer, OneOptional>> p1 = new Ice.Optional<java.util.Map<Integer, OneOptional>>();
2123             Ice.Optional<java.util.Map<Integer, OneOptional>> p3 = new Ice.Optional<java.util.Map<Integer, OneOptional>>();
2124             Ice.Optional<java.util.Map<Integer, OneOptional>> p2 = initial.opIntOneOptionalDict(p1, p3);
2125             test(!p2.isSet() && !p3.isSet());
2126 
2127             p1.set(new java.util.HashMap<Integer, OneOptional>());
2128             p1.get().put(1, new OneOptional(15));
2129             p1.get().put(2, new OneOptional(12));
2130             p2 = initial.opIntOneOptionalDict(p1, p3);
2131             test(p2.get().get(1).getA() == 15 && p3.get().get(1).getA() == 15);
2132             test(p2.get().get(2).getA() == 12 && p3.get().get(2).getA() == 12);
2133             Ice.AsyncResult r = initial.begin_opIntOneOptionalDict(p1);
2134             p2 = initial.end_opIntOneOptionalDict(p3, r);
2135             test(p2.get().get(1).getA() == 15 && p3.get().get(1).getA() == 15);
2136             test(p2.get().get(2).getA() == 12 && p3.get().get(2).getA() == 12);
2137             p2 = initial.opIntOneOptionalDict(new Ice.Optional<java.util.Map<Integer, OneOptional>>(), p3);
2138             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
2139 
2140             if(reqParams)
2141             {
2142                 p2 = initial.opIntOneOptionalDictReq(p1.get(), p3);
2143                 test(p2.get().get(1).getA() == 15 && p3.get().get(1).getA() == 15);
2144                 test(p2.get().get(2).getA() == 12 && p3.get().get(2).getA() == 12);
2145                 r = initial.begin_opIntOneOptionalDictReq(p1.get());
2146                 p2 = initial.end_opIntOneOptionalDictReq(p3, r);
2147                 test(p2.get().get(1).getA() == 15 && p3.get().get(1).getA() == 15);
2148                 test(p2.get().get(2).getA() == 12 && p3.get().get(2).getA() == 12);
2149 
2150                 os = new Ice.OutputStream(communicator);
2151                 os.startEncapsulation();
2152                 os.writeOptional(2, Ice.OptionalFormat.FSize);
2153                 int pos = os.startSize();
2154                 IntOneOptionalDictHelper.write(os, p1.get());
2155                 os.endSize(pos);
2156                 os.endEncapsulation();
2157                 inEncaps = os.finished();
2158                 initial.ice_invoke("opIntOneOptionalDictReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
2159                 in = new Ice.InputStream(communicator, outEncaps.value);
2160                 in.startEncapsulation();
2161                 test(in.readOptional(1, Ice.OptionalFormat.FSize));
2162                 in.skip(4);
2163                 java.util.Map<Integer, OneOptional> m = IntOneOptionalDictHelper.read(in);
2164                 test(m.get(1).getA() == 15 && m.get(2).getA() == 12);
2165                 test(in.readOptional(3, Ice.OptionalFormat.FSize));
2166                 in.skip(4);
2167                 m = IntOneOptionalDictHelper.read(in);
2168                 test(m.get(1).getA() == 15 && m.get(2).getA() == 12);
2169                 in.endEncapsulation();
2170 
2171                 in = new Ice.InputStream(communicator, outEncaps.value);
2172                 in.startEncapsulation();
2173                 in.endEncapsulation();
2174             }
2175         }
2176 
2177         {
2178             F f = new F();
2179             f.setAf(new A());
2180             f.getAf().requiredA = 56;
2181             f.ae = f.getAf();
2182 
2183             os = new Ice.OutputStream(communicator);
2184             os.startEncapsulation();
2185             os.writeOptional(1, Ice.OptionalFormat.Class);
2186             os.writeValue(f);
2187             os.writeOptional(2, Ice.OptionalFormat.Class);
2188             os.writeValue(f.ae);
2189             os.endEncapsulation();
2190             inEncaps = os.finished();
2191 
2192             in = new Ice.InputStream(communicator, inEncaps);
2193             in.startEncapsulation();
2194             test(in.readOptional(2, Ice.OptionalFormat.Class));
2195             final AHolder a = new AHolder();
2196             in.readValue(new Ice.ReadValueCallback()
2197                 {
2198                     @Override
2199                     public void valueReady(Ice.Object obj)
2200                     {
2201                         a.value = (A)obj;
2202                     }
2203                 });
2204             in.endEncapsulation();
2205             test(a.value != null && a.value.requiredA == 56);
2206         }
2207         out.println("ok");
2208 
2209         out.print("testing exception optionals... ");
2210         out.flush();
2211         {
2212             try
2213             {
2214                 Ice.IntOptional a = new Ice.IntOptional();
2215                 Ice.Optional<String> b = new Ice.Optional<String>();
2216                 Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>();
2217                 initial.opOptionalException(a, b, o);
2218             }
2219             catch(OptionalException ex)
2220             {
2221                 test(!ex.hasA());
2222                 test(!ex.hasB());
2223                 test(!ex.hasO());
2224             }
2225 
2226             try
2227             {
2228                 Ice.IntOptional a = new Ice.IntOptional(30);
2229                 Ice.Optional<String> b = new Ice.Optional<String>("test");
2230                 Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>(new OneOptional(53));
2231                 initial.opOptionalException(a, b, o);
2232             }
2233             catch(OptionalException ex)
2234             {
2235                 test(ex.getA() == 30);
2236                 test(ex.getB().equals("test"));
2237                 test(ex.getO().getA() == 53);
2238             }
2239 
2240             try
2241             {
2242                 //
2243                 // Use the 1.0 encoding with an exception whose only class members are optional.
2244                 //
2245                 Ice.IntOptional a = new Ice.IntOptional(30);
2246                 Ice.Optional<String> b = new Ice.Optional<String>("test");
2247                 Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>(new OneOptional(53));
2248                 initial2.opOptionalException(a, b, o);
2249             }
2250             catch(OptionalException ex)
2251             {
2252                 test(!ex.hasA());
2253                 test(!ex.hasB());
2254                 test(!ex.hasO());
2255             }
2256 
2257             try
2258             {
2259                 Ice.IntOptional a = new Ice.IntOptional();
2260                 Ice.Optional<String> b = new Ice.Optional<String>();
2261                 Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>();
2262                 initial.opDerivedException(a, b, o);
2263             }
2264             catch(DerivedException ex)
2265             {
2266                 test(!ex.hasA());
2267                 test(!ex.hasB());
2268                 test(!ex.hasO());
2269                 test(!ex.hasSs());
2270                 test(!ex.hasO2());
2271             }
2272             catch(OptionalException ex)
2273             {
2274                 test(false);
2275             }
2276 
2277             try
2278             {
2279                 Ice.IntOptional a = new Ice.IntOptional(30);
2280                 Ice.Optional<String> b = new Ice.Optional<String>("test2");
2281                 Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>(new OneOptional(53));
2282                 initial.opDerivedException(a, b, o);
2283             }
2284             catch(DerivedException ex)
2285             {
2286                 test(ex.getA() == 30);
2287                 test(ex.getB().equals("test2"));
2288                 test(ex.getO().getA() == 53);
2289                 test(ex.getSs().equals("test2"));
2290                 test(ex.getO2().getA() == 53);
2291             }
2292             catch(OptionalException ex)
2293             {
2294                 test(false);
2295             }
2296 
2297             try
2298             {
2299                 Ice.IntOptional a = new Ice.IntOptional();
2300                 Ice.Optional<String> b = new Ice.Optional<String>();
2301                 Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>();
2302                 initial.opRequiredException(a, b, o);
2303             }
2304             catch(RequiredException ex)
2305             {
2306                 test(!ex.hasA());
2307                 test(!ex.hasB());
2308                 test(!ex.hasO());
2309                 test(ex.ss.equals("test"));
2310                 test(ex.o2 == null);
2311             }
2312             catch(OptionalException ex)
2313             {
2314                 test(false);
2315             }
2316 
2317             try
2318             {
2319                 Ice.IntOptional a = new Ice.IntOptional(30);
2320                 Ice.Optional<String> b = new Ice.Optional<String>("test2");
2321                 Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>(new OneOptional(53));
2322                 initial.opRequiredException(a, b, o);
2323             }
2324             catch(RequiredException ex)
2325             {
2326                 test(ex.getA() == 30);
2327                 test(ex.getB().equals("test2"));
2328                 test(ex.getO().getA() == 53);
2329                 test(ex.ss.equals("test2"));
2330                 test(ex.o2.getA() == 53);
2331             }
2332             catch(OptionalException ex)
2333             {
2334                 test(false);
2335             }
2336         }
2337         out.println("ok");
2338 
2339         //
2340         // Use reflection to load TwowaysLambdaAMI as that is only supported with Java >= 1.8
2341         //
2342         try
2343         {
2344             Class<?> cls = IceInternal.Util.findClass("test.Ice.optional.lambda.AllTests", null);
2345             if(cls != null)
2346             {
2347                 java.lang.reflect.Method allTests = cls.getDeclaredMethod("allTests",
2348                     new Class<?>[]{test.TestHelper.class});
2349                 allTests.invoke(null, helper);
2350             }
2351         }
2352         catch(java.lang.NoSuchMethodException ex)
2353         {
2354             throw new RuntimeException(ex);
2355         }
2356         catch(java.lang.IllegalAccessException ex)
2357         {
2358             throw new RuntimeException(ex);
2359         }
2360         catch(java.lang.reflect.InvocationTargetException ex)
2361         {
2362             throw new RuntimeException(ex);
2363         }
2364 
2365         return initial;
2366     }
2367 
2368     private static class TestObjectReader extends Ice.ObjectReader
2369     {
2370         @Override
read(Ice.InputStream in)2371         public void read(Ice.InputStream in)
2372         {
2373             in.startValue();
2374             in.startSlice();
2375             in.endSlice();
2376             in.endValue(false);
2377         }
2378     }
2379 
2380     private static class BObjectReader extends Ice.ObjectReader
2381     {
2382         @Override
read(Ice.InputStream in)2383         public void read(Ice.InputStream in)
2384         {
2385             in.startValue();
2386             // ::Test::B
2387             in.startSlice();
2388             in.readInt();
2389             in.endSlice();
2390             // ::Test::A
2391             in.startSlice();
2392             in.readInt();
2393             in.endSlice();
2394             in.endValue(false);
2395         }
2396     }
2397 
2398     private static class CObjectReader extends Ice.ObjectReader
2399     {
2400         @Override
read(Ice.InputStream in)2401         public void read(Ice.InputStream in)
2402         {
2403             in.startValue();
2404             // ::Test::C
2405             in.startSlice();
2406             in.skipSlice();
2407             // ::Test::B
2408             in.startSlice();
2409             in.readInt();
2410             in.endSlice();
2411             // ::Test::A
2412             in.startSlice();
2413             in.readInt();
2414             in.endSlice();
2415             in.endValue(false);
2416         }
2417     }
2418 
2419     private static class DObjectWriter extends Ice.ObjectWriter
2420     {
2421         @Override
write(Ice.OutputStream out)2422         public void write(Ice.OutputStream out)
2423         {
2424             out.startValue(null);
2425             // ::Test::D
2426             out.startSlice("::Test::D", -1, false);
2427             out.writeString("test");
2428             out.writeOptional(1, Ice.OptionalFormat.FSize);
2429             String[] o = { "test1", "test2", "test3", "test4" };
2430             int pos = out.startSize();
2431             out.writeStringSeq(o);
2432             out.endSize(pos);
2433             A a = new A();
2434             a.setMc(18);
2435             out.writeOptional(1000, Ice.OptionalFormat.Class);
2436             out.writeValue(a);
2437             out.endSlice();
2438             // ::Test::B
2439             out.startSlice(B.ice_staticId(), -1, false);
2440             int v = 14;
2441             out.writeInt(v);
2442             out.endSlice();
2443             // ::Test::A
2444             out.startSlice(A.ice_staticId(), -1, true);
2445             out.writeInt(v);
2446             out.endSlice();
2447             out.endValue();
2448         }
2449     }
2450 
2451     private static class DObjectReader extends Ice.ObjectReader
2452     {
2453         @Override
read(Ice.InputStream in)2454         public void read(Ice.InputStream in)
2455         {
2456             in.startValue();
2457             // ::Test::D
2458             in.startSlice();
2459             String s = in.readString();
2460             test(s.equals("test"));
2461             test(in.readOptional(1, Ice.OptionalFormat.FSize));
2462             in.skip(4);
2463             String[] o = in.readStringSeq();
2464             test(o.length == 4 &&
2465                  o[0].equals("test1") && o[1].equals("test2") && o[2].equals("test3") && o[3].equals("test4"));
2466             test(in.readOptional(1000, Ice.OptionalFormat.Class));
2467             in.readValue(a);
2468             in.endSlice();
2469             // ::Test::B
2470             in.startSlice();
2471             in.readInt();
2472             in.endSlice();
2473             // ::Test::A
2474             in.startSlice();
2475             in.readInt();
2476             in.endSlice();
2477             in.endValue(false);
2478         }
2479 
check()2480         void check()
2481         {
2482             test(((A)a.obj).getMc() == 18);
2483         }
2484 
2485         private ReadValueCallbackI a = new ReadValueCallbackI();
2486     }
2487 
2488     private static class FObjectReader extends Ice.ObjectReader
2489     {
2490         @Override
read(Ice.InputStream in)2491         public void read(Ice.InputStream in)
2492         {
2493             _f = new F();
2494             in.startValue();
2495             in.startSlice();
2496             // Don't read af on purpose
2497             //in.read(1, _f.af);
2498             in.endSlice();
2499             in.startSlice();
2500             in.readValue(new Ice.ReadValueCallback()
2501                 {
2502                     @Override
2503                     public void valueReady(Ice.Object obj)
2504                     {
2505                         _f.ae = (A)obj;
2506                     }
2507                 });
2508             in.endSlice();
2509             in.endValue(false);
2510         }
2511 
getF()2512         F getF()
2513         {
2514             return _f;
2515         }
2516 
2517         private F _f;
2518     }
2519 
2520     private static class FactoryI implements Ice.ValueFactory
2521     {
2522         @Override
create(String typeId)2523         public Ice.Object create(String typeId)
2524         {
2525             if(!_enabled)
2526             {
2527                 return null;
2528             }
2529 
2530             if(typeId.equals(OneOptional.ice_staticId()))
2531             {
2532                 return new TestObjectReader();
2533             }
2534             else if(typeId.equals(MultiOptional.ice_staticId()))
2535             {
2536                 return new TestObjectReader();
2537             }
2538             else if(typeId.equals(B.ice_staticId()))
2539             {
2540                 return new BObjectReader();
2541             }
2542             else if(typeId.equals(C.ice_staticId()))
2543             {
2544                 return new CObjectReader();
2545             }
2546             else if(typeId.equals("::Test::D"))
2547             {
2548                 return new DObjectReader();
2549             }
2550             else if(typeId.equals("::Test::F"))
2551             {
2552                 return new FObjectReader();
2553             }
2554 
2555             return null;
2556         }
2557 
setEnabled(boolean enabled)2558         void setEnabled(boolean enabled)
2559         {
2560             _enabled = enabled;
2561         }
2562 
2563         private boolean _enabled;
2564     }
2565 
2566     private static class ReadValueCallbackI implements Ice.ReadValueCallback
2567     {
2568         @Override
valueReady(Ice.Object obj)2569         public void valueReady(Ice.Object obj)
2570         {
2571             this.obj = obj;
2572         }
2573 
2574         Ice.Object obj;
2575     }
2576 }
2577