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