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