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