summaryrefslogtreecommitdiff
path: root/java/test/Ice/optional/AllTests.java
diff options
context:
space:
mode:
Diffstat (limited to 'java/test/Ice/optional/AllTests.java')
-rw-r--r--java/test/Ice/optional/AllTests.java1091
1 files changed, 1044 insertions, 47 deletions
diff --git a/java/test/Ice/optional/AllTests.java b/java/test/Ice/optional/AllTests.java
index 3f8f2ca8722..98538ba7311 100644
--- a/java/test/Ice/optional/AllTests.java
+++ b/java/test/Ice/optional/AllTests.java
@@ -317,6 +317,21 @@ public class AllTests
test(!mo9.hasBos());
+ {
+ OptionalWithCustom owc1 = new OptionalWithCustom();
+ java.util.ArrayList<Byte> l = new java.util.ArrayList<Byte>();
+ l.add((byte)5);
+ l.add((byte)6);
+ l.add((byte)7);
+ owc1.setBs(l);
+ owc1.setS(new ClassVarStruct(5));
+ OptionalWithCustom owc2 = (OptionalWithCustom)initial.pingPong(owc1);
+ test(owc2.hasBs());
+ test(owc2.getBs().equals(l));
+ test(owc2.hasS());
+ test(owc2.getS().a == 5);
+ }
+
//
// Send a request using blobjects. Upon receival, we don't read
// any of the optional members. This ensures the optional members
@@ -509,16 +524,24 @@ public class AllTests
out.print("testing optional parameters... ");
out.flush();
{
- Ice.Optional<Byte> p1 = new Ice.Optional<Byte>();
- Ice.Optional<Byte> p3 = new Ice.Optional<Byte>();
- Ice.Optional<Byte> p2 = initial.opByte(p1, p3);
+ Ice.ByteOptional p1 = new Ice.ByteOptional();
+ Ice.ByteOptional p3 = new Ice.ByteOptional();
+ Ice.ByteOptional p2 = initial.opByteOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set((byte)56);
- p2 = initial.opByte(p1, p3);
+ p2 = initial.opByteOpt(p1, p3);
+ test(p2.get() == (byte)56 && p3.get() == (byte)56);
+ Ice.AsyncResult r = initial.begin_opByteOpt(p1);
+ p2 = initial.end_opByteOpt(p3, r);
+ test(p2.get() == (byte)56 && p3.get() == (byte)56);
+ p2 = initial.opByte(p1.get(), p3);
+ test(p2.get() == (byte)56 && p3.get() == (byte)56);
+ r = initial.begin_opByte(p1.get());
+ p2 = initial.end_opByte(p3, r);
test(p2.get() == (byte)56 && p3.get() == (byte)56);
- p2 = initial.opByte(new Ice.Optional<Byte>(), p3);
+ p2 = initial.opByteOpt(new Ice.ByteOptional(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -542,16 +565,147 @@ public class AllTests
}
{
- Ice.Optional<Long> p1 = new Ice.Optional<Long>();
- Ice.Optional<Long> p3 = new Ice.Optional<Long>();
- Ice.Optional<Long> p2 = initial.opLong(p1, p3);
+ Ice.BooleanOptional p1 = new Ice.BooleanOptional();
+ Ice.BooleanOptional p3 = new Ice.BooleanOptional();
+ Ice.BooleanOptional p2 = initial.opBoolOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(true);
+ p2 = initial.opBoolOpt(p1, p3);
+ test(p2.get() == true && p3.get() == true);
+ Ice.AsyncResult r = initial.begin_opBoolOpt(p1);
+ p2 = initial.end_opBoolOpt(p3, r);
+ test(p2.get() == true && p3.get() == true);
+ p2 = initial.opBool(true, p3);
+ test(p2.get() == true && p3.get() == true);
+ r = initial.begin_opBool(true);
+ p2 = initial.end_opBool(p3, r);
+ test(p2.get() == true && p3.get() == true);
+
+ p2 = initial.opBoolOpt(new Ice.BooleanOptional(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.F1);
+ os.writeBool(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opBool", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.F1));
+ test(in.readBool() == true);
+ test(in.readOptional(3, Ice.OptionalType.F1));
+ test(in.readBool() == true);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.ShortOptional p1 = new Ice.ShortOptional();
+ Ice.ShortOptional p3 = new Ice.ShortOptional();
+ Ice.ShortOptional p2 = initial.opShortOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set((short)56);
+ p2 = initial.opShortOpt(p1, p3);
+ test(p2.get() == 56 && p3.get() == 56);
+ Ice.AsyncResult r = initial.begin_opShortOpt(p1);
+ p2 = initial.end_opShortOpt(p3, r);
+ test(p2.get() == 56 && p3.get() == 56);
+ p2 = initial.opShort(p1.get(), p3);
+ test(p2.get() == 56 && p3.get() == 56);
+ r = initial.begin_opShort(p1.get());
+ p2 = initial.end_opShort(p3, r);
+ test(p2.get() == 56 && p3.get() == 56);
+
+ p2 = initial.opShortOpt(new Ice.ShortOptional(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.F2);
+ os.writeShort(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opShort", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.F2));
+ test(in.readShort() == 56);
+ test(in.readOptional(3, Ice.OptionalType.F2));
+ test(in.readShort() == 56);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.IntOptional p1 = new Ice.IntOptional();
+ Ice.IntOptional p3 = new Ice.IntOptional();
+ Ice.IntOptional p2 = initial.opIntOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(56);
+ p2 = initial.opIntOpt(p1, p3);
+ test(p2.get() == 56 && p3.get() == 56);
+ Ice.AsyncResult r = initial.begin_opIntOpt(p1);
+ p2 = initial.end_opIntOpt(p3, r);
+ test(p2.get() == 56 && p3.get() == 56);
+ p2 = initial.opInt(p1.get(), p3);
+ test(p2.get() == 56 && p3.get() == 56);
+ r = initial.begin_opInt(p1.get());
+ p2 = initial.end_opInt(p3, r);
+ test(p2.get() == 56 && p3.get() == 56);
+
+ p2 = initial.opIntOpt(new Ice.IntOptional(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.F4);
+ os.writeInt(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opInt", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.F4));
+ test(in.readInt() == 56);
+ test(in.readOptional(3, Ice.OptionalType.F4));
+ test(in.readInt() == 56);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.LongOptional p1 = new Ice.LongOptional();
+ Ice.LongOptional p3 = new Ice.LongOptional();
+ Ice.LongOptional p2 = initial.opLongOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
- p1.set((long)56);
- p2 = initial.opLong(p1, p3);
+ p1.set(56);
+ p2 = initial.opLongOpt(p1, p3);
+ test(p2.get() == 56 && p3.get() == 56);
+ Ice.AsyncResult r = initial.begin_opLongOpt(p1);
+ p2 = initial.end_opLongOpt(p3, r);
+ test(p2.get() == 56 && p3.get() == 56);
+ p2 = initial.opLong(p1.get(), p3);
+ test(p2.get() == 56 && p3.get() == 56);
+ r = initial.begin_opLong(p1.get());
+ p2 = initial.end_opLong(p3, r);
test(p2.get() == 56 && p3.get() == 56);
- p2 = initial.opLong(new Ice.Optional<Long>(), p3);
+ p2 = initial.opLongOpt(new Ice.LongOptional(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -575,16 +729,106 @@ public class AllTests
}
{
+ Ice.FloatOptional p1 = new Ice.FloatOptional();
+ Ice.FloatOptional p3 = new Ice.FloatOptional();
+ Ice.FloatOptional p2 = initial.opFloatOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set((float)1.0);
+ p2 = initial.opFloatOpt(p1, p3);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+ Ice.AsyncResult r = initial.begin_opFloatOpt(p1);
+ p2 = initial.end_opFloatOpt(p3, r);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+ p2 = initial.opFloat(p1.get(), p3);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+ r = initial.begin_opFloat(p1.get());
+ p2 = initial.end_opFloat(p3, r);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+
+ p2 = initial.opFloatOpt(new Ice.FloatOptional(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.F4);
+ os.writeFloat(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opFloat", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.F4));
+ test(in.readFloat() == 1.0);
+ test(in.readOptional(3, Ice.OptionalType.F4));
+ test(in.readFloat() == 1.0);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.DoubleOptional p1 = new Ice.DoubleOptional();
+ Ice.DoubleOptional p3 = new Ice.DoubleOptional();
+ Ice.DoubleOptional p2 = initial.opDoubleOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(1.0);
+ p2 = initial.opDoubleOpt(p1, p3);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+ Ice.AsyncResult r = initial.begin_opDoubleOpt(p1);
+ p2 = initial.end_opDoubleOpt(p3, r);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+ p2 = initial.opDouble(p1.get(), p3);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+ r = initial.begin_opDouble(p1.get());
+ p2 = initial.end_opDouble(p3, r);
+ test(p2.get() == 1.0 && p3.get() == 1.0);
+
+ p2 = initial.opDoubleOpt(new Ice.DoubleOptional(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.F8);
+ os.writeDouble(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opDouble", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.F8));
+ test(in.readDouble() == 1.0);
+ test(in.readOptional(3, Ice.OptionalType.F8));
+ test(in.readDouble() == 1.0);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
Ice.Optional<String> p1 = new Ice.Optional<String>();
Ice.Optional<String> p3 = new Ice.Optional<String>();
- Ice.Optional<String> p2 = initial.opString(p1, p3);
+ Ice.Optional<String> p2 = initial.opStringOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set("test");
- p2 = initial.opString(p1, p3);
+ p2 = initial.opStringOpt(p1, p3);
+ test(p2.get().equals("test") && p3.get().equals("test"));
+ Ice.AsyncResult r = initial.begin_opStringOpt(p1);
+ p2 = initial.end_opStringOpt(p3, r);
+ test(p2.get().equals("test") && p3.get().equals("test"));
+ p2 = initial.opString(p1.get(), p3);
+ test(p2.get().equals("test") && p3.get().equals("test"));
+ r = initial.begin_opString(p1.get());
+ p2 = initial.end_opString(p3, r);
test(p2.get().equals("test") && p3.get().equals("test"));
- p2 = initial.opString(new Ice.Optional<String>(), p3);
+ p2 = initial.opStringOpt(new Ice.Optional<String>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -608,16 +852,207 @@ public class AllTests
}
{
+ Ice.Optional<MyEnum> p1 = new Ice.Optional<MyEnum>();
+ Ice.Optional<MyEnum> p3 = new Ice.Optional<MyEnum>();
+ Ice.Optional<MyEnum> p2 = initial.opMyEnumOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(MyEnum.MyEnumMember);
+ p2 = initial.opMyEnumOpt(p1, p3);
+ test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
+ Ice.AsyncResult r = initial.begin_opMyEnumOpt(p1);
+ p2 = initial.end_opMyEnumOpt(p3, r);
+ test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
+ p2 = initial.opMyEnum(p1.get(), p3);
+ test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
+ r = initial.begin_opMyEnum(p1.get());
+ p2 = initial.end_opMyEnum(p3, r);
+ test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
+
+ p2 = initial.opMyEnumOpt(new Ice.Optional<MyEnum>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.Size);
+ p1.get().ice_write(os);
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opMyEnum", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.Size));
+ test(MyEnum.ice_read(in) == MyEnum.MyEnumMember);
+ test(in.readOptional(3, Ice.OptionalType.Size));
+ test(MyEnum.ice_read(in) == MyEnum.MyEnumMember);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<SmallStruct> p1 = new Ice.Optional<SmallStruct>();
+ Ice.Optional<SmallStruct> p3 = new Ice.Optional<SmallStruct>();
+ Ice.Optional<SmallStruct> p2 = initial.opSmallStructOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new SmallStruct((byte)56));
+ p2 = initial.opSmallStructOpt(p1, p3);
+ test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
+ Ice.AsyncResult r = initial.begin_opSmallStructOpt(p1);
+ p2 = initial.end_opSmallStructOpt(p3, r);
+ test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
+ p2 = initial.opSmallStruct(p1.get(), p3);
+ test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
+ r = initial.begin_opSmallStruct(p1.get());
+ p2 = initial.end_opSmallStruct(p3, r);
+ test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
+
+ p2 = initial.opSmallStructOpt(new Ice.Optional<SmallStruct>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(1);
+ p1.get().ice_write(os);
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opSmallStruct", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ SmallStruct f = new SmallStruct();
+ f.ice_read(in);
+ test(f.m == (byte)56);
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ f.ice_read(in);
+ test(f.m == (byte)56);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<FixedStruct> p1 = new Ice.Optional<FixedStruct>();
+ Ice.Optional<FixedStruct> p3 = new Ice.Optional<FixedStruct>();
+ Ice.Optional<FixedStruct> p2 = initial.opFixedStructOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new FixedStruct(56));
+ p2 = initial.opFixedStructOpt(p1, p3);
+ test(p2.get().m == 56 && p3.get().m == 56);
+ Ice.AsyncResult r = initial.begin_opFixedStructOpt(p1);
+ p2 = initial.end_opFixedStructOpt(p3, r);
+ test(p2.get().m == 56 && p3.get().m == 56);
+ p2 = initial.opFixedStruct(p1.get(), p3);
+ test(p2.get().m == 56 && p3.get().m == 56);
+ r = initial.begin_opFixedStruct(p1.get());
+ p2 = initial.end_opFixedStruct(p3, r);
+ test(p2.get().m == 56 && p3.get().m == 56);
+
+ p2 = initial.opFixedStructOpt(new Ice.Optional<FixedStruct>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(4);
+ p1.get().ice_write(os);
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opFixedStruct", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ FixedStruct f = new FixedStruct();
+ f.ice_read(in);
+ test(f.m == 56);
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ f.ice_read(in);
+ test(f.m == 56);
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<VarStruct> p1 = new Ice.Optional<VarStruct>();
+ Ice.Optional<VarStruct> p3 = new Ice.Optional<VarStruct>();
+ Ice.Optional<VarStruct> p2 = initial.opVarStructOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new VarStruct("test"));
+ p2 = initial.opVarStructOpt(p1, p3);
+ test(p2.get().m.equals("test") && p3.get().m.equals("test"));
+ Ice.AsyncResult r = initial.begin_opVarStructOpt(p1);
+ p2 = initial.end_opVarStructOpt(p3, r);
+ test(p2.get().m.equals("test") && p3.get().m.equals("test"));
+ p2 = initial.opVarStruct(p1.get(), p3);
+ test(p2.get().m.equals("test") && p3.get().m.equals("test"));
+ r = initial.begin_opVarStruct(p1.get());
+ p2 = initial.end_opVarStruct(p3, r);
+ test(p2.get().m.equals("test") && p3.get().m.equals("test"));
+
+ p2 = initial.opVarStructOpt(new Ice.Optional<VarStruct>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.FSize);
+ os.startSize();
+ p1.get().ice_write(os);
+ os.endSize();
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opVarStruct", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.FSize));
+ in.skip(4);
+ VarStruct v = new VarStruct();
+ v.ice_read(in);
+ test(v.m.equals("test"));
+ test(in.readOptional(3, Ice.OptionalType.FSize));
+ in.skip(4);
+ v.ice_read(in);
+ test(v.m.equals("test"));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
Ice.Optional<OneOptional> p1 = new Ice.Optional<OneOptional>();
Ice.Optional<OneOptional> p3 = new Ice.Optional<OneOptional>();
- Ice.Optional<OneOptional> p2 = initial.opOneOptional(p1, p3);
+ Ice.Optional<OneOptional> p2 = initial.opOneOptionalOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set(new OneOptional(58));
- p2 = initial.opOneOptional(p1, p3);
+ p2 = initial.opOneOptionalOpt(p1, p3);
+ test(p2.get().getA() == 58 && p3.get().getA() == 58);
+ Ice.AsyncResult r = initial.begin_opOneOptionalOpt(p1);
+ p2 = initial.end_opOneOptionalOpt(p3, r);
+ test(p2.get().getA() == 58 && p3.get().getA() == 58);
+ p2 = initial.opOneOptional(p1.get(), p3);
+ test(p2.get().getA() == 58 && p3.get().getA() == 58);
+ r = initial.begin_opOneOptional(p1.get());
+ p2 = initial.end_opOneOptional(p3, r);
test(p2.get().getA() == 58 && p3.get().getA() == 58);
- p2 = initial.opOneOptional(new Ice.Optional<OneOptional>(), p3);
+ p2 = initial.opOneOptionalOpt(new Ice.Optional<OneOptional>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -646,14 +1081,22 @@ public class AllTests
{
Ice.Optional<OneOptionalPrx> p1 = new Ice.Optional<OneOptionalPrx>();
Ice.Optional<OneOptionalPrx> p3 = new Ice.Optional<OneOptionalPrx>();
- Ice.Optional<OneOptionalPrx> p2 = initial.opOneOptionalProxy(p1, p3);
+ Ice.Optional<OneOptionalPrx> p2 = initial.opOneOptionalProxyOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test")));
- p2 = initial.opOneOptionalProxy(p1, p3);
+ p2 = initial.opOneOptionalProxyOpt(p1, p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ Ice.AsyncResult r = initial.begin_opOneOptionalProxyOpt(p1);
+ p2 = initial.end_opOneOptionalProxyOpt(p3, r);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ p2 = initial.opOneOptionalProxy(p1.get(), p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ r = initial.begin_opOneOptionalProxy(p1.get());
+ p2 = initial.end_opOneOptionalProxy(p3, r);
test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
- p2 = initial.opOneOptionalProxy(new Ice.Optional<OneOptionalPrx>(), p3);
+ p2 = initial.opOneOptionalProxyOpt(new Ice.Optional<OneOptionalPrx>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -683,15 +1126,23 @@ public class AllTests
{
Ice.Optional<byte[]> p1 = new Ice.Optional<byte[]>();
Ice.Optional<byte[]> p3 = new Ice.Optional<byte[]>();
- Ice.Optional<byte[]> p2 = initial.opByteSeq(p1, p3);
+ Ice.Optional<byte[]> p2 = initial.opByteSeqOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set(new byte[100]);
java.util.Arrays.fill(p1.get(), (byte)56);
- p2 = initial.opByteSeq(p1, p3);
+ p2 = initial.opByteSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opByteSeqOpt(p1);
+ p2 = initial.end_opByteSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opByteSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opByteSeq(p1.get());
+ p2 = initial.end_opByteSeq(p3, r);
test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
- p2 = initial.opByteSeq(new Ice.Optional<byte[]>(), p3);
+ p2 = initial.opByteSeqOpt(new Ice.Optional<byte[]>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -715,17 +1166,66 @@ public class AllTests
}
{
+ Ice.Optional<boolean[]> p1 = new Ice.Optional<boolean[]>();
+ Ice.Optional<boolean[]> p3 = new Ice.Optional<boolean[]>();
+ Ice.Optional<boolean[]> p2 = initial.opBoolSeqOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new boolean[100]);
+ p2 = initial.opBoolSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opBoolSeqOpt(p1);
+ p2 = initial.end_opBoolSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opBoolSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opBoolSeq(p1.get());
+ p2 = initial.end_opBoolSeq(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+
+ p2 = initial.opBoolSeqOpt(new Ice.Optional<boolean[]>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeBoolSeq(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opBoolSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
Ice.Optional<short[]> p1 = new Ice.Optional<short[]>();
Ice.Optional<short[]> p3 = new Ice.Optional<short[]>();
- Ice.Optional<short[]> p2 = initial.opShortSeq(p1, p3);
+ Ice.Optional<short[]> p2 = initial.opShortSeqOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set(new short[100]);
java.util.Arrays.fill(p1.get(), (short)56);
- p2 = initial.opShortSeq(p1, p3);
+ p2 = initial.opShortSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opShortSeqOpt(p1);
+ p2 = initial.end_opShortSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opShortSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opShortSeq(p1.get());
+ p2 = initial.end_opShortSeq(p3, r);
test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
- p2 = initial.opShortSeq(new Ice.Optional<short[]>(), p3);
+ p2 = initial.opShortSeqOpt(new Ice.Optional<short[]>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -752,31 +1252,178 @@ public class AllTests
}
{
- Ice.Optional<boolean[]> p1 = new Ice.Optional<boolean[]>();
- Ice.Optional<boolean[]> p3 = new Ice.Optional<boolean[]>();
- Ice.Optional<boolean[]> p2 = initial.opBoolSeq(p1, p3);
+ Ice.Optional<int[]> p1 = new Ice.Optional<int[]>();
+ Ice.Optional<int[]> p3 = new Ice.Optional<int[]>();
+ Ice.Optional<int[]> p2 = initial.opIntSeqOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
- p1.set(new boolean[100]);
- p2 = initial.opBoolSeq(p1, p3);
+ p1.set(new int[100]);
+ java.util.Arrays.fill(p1.get(), 56);
+ p2 = initial.opIntSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opIntSeqOpt(p1);
+ p2 = initial.end_opIntSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opIntSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opIntSeq(p1.get());
+ p2 = initial.end_opIntSeq(p3, r);
test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
- p2 = initial.opBoolSeq(new Ice.Optional<boolean[]>(), p3);
+ p2 = initial.opIntSeqOpt(new Ice.Optional<int[]>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
os.startEncapsulation();
os.writeOptional(2, Ice.OptionalType.VSize);
- os.writeBoolSeq(p1.get());
+ os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
+ os.writeIntSeq(p1.get());
os.endEncapsulation();
inEncaps = os.finished();
- initial.ice_invoke("opBoolSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ initial.ice_invoke("opIntSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
in = Ice.Util.createInputStream(communicator, outEncaps.value);
in.startEncapsulation();
test(in.readOptional(1, Ice.OptionalType.VSize));
- test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readIntSeq(), p1.get()));
test(in.readOptional(3, Ice.OptionalType.VSize));
- test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readIntSeq(), p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<long[]> p1 = new Ice.Optional<long[]>();
+ Ice.Optional<long[]> p3 = new Ice.Optional<long[]>();
+ Ice.Optional<long[]> p2 = initial.opLongSeqOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new long[100]);
+ java.util.Arrays.fill(p1.get(), 56);
+ p2 = initial.opLongSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opLongSeqOpt(p1);
+ p2 = initial.end_opLongSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opLongSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opLongSeq(p1.get());
+ p2 = initial.end_opLongSeq(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+
+ p2 = initial.opLongSeqOpt(new Ice.Optional<long[]>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(p1.get().length * 8 + (p1.get().length > 254 ? 5 : 1));
+ os.writeLongSeq(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opLongSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readLongSeq(), p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readLongSeq(), p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<float[]> p1 = new Ice.Optional<float[]>();
+ Ice.Optional<float[]> p3 = new Ice.Optional<float[]>();
+ Ice.Optional<float[]> p2 = initial.opFloatSeqOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new float[100]);
+ java.util.Arrays.fill(p1.get(), (float)1.0);
+ p2 = initial.opFloatSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opFloatSeqOpt(p1);
+ p2 = initial.end_opFloatSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opFloatSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opFloatSeq(p1.get());
+ p2 = initial.end_opFloatSeq(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+
+ p2 = initial.opFloatSeqOpt(new Ice.Optional<float[]>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
+ os.writeFloatSeq(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opFloatSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readFloatSeq(), p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readFloatSeq(), p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<double[]> p1 = new Ice.Optional<double[]>();
+ Ice.Optional<double[]> p3 = new Ice.Optional<double[]>();
+ Ice.Optional<double[]> p2 = initial.opDoubleSeqOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new double[100]);
+ java.util.Arrays.fill(p1.get(), 1.0);
+ p2 = initial.opDoubleSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opDoubleSeqOpt(p1);
+ p2 = initial.end_opDoubleSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opDoubleSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opDoubleSeq(p1.get());
+ p2 = initial.end_opDoubleSeq(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+
+ p2 = initial.opDoubleSeqOpt(new Ice.Optional<double[]>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(p1.get().length * 8 + (p1.get().length > 254 ? 5 : 1));
+ os.writeDoubleSeq(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opDoubleSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
in.endEncapsulation();
in = Ice.Util.createInputStream(communicator, outEncaps.value);
@@ -787,15 +1434,23 @@ public class AllTests
{
Ice.Optional<String[]> p1 = new Ice.Optional<String[]>();
Ice.Optional<String[]> p3 = new Ice.Optional<String[]>();
- Ice.Optional<String[]> p2 = initial.opStringSeq(p1, p3);
+ Ice.Optional<String[]> p2 = initial.opStringSeqOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set(new String[10]);
java.util.Arrays.fill(p1.get(), "test1");
- p2 = initial.opStringSeq(p1, p3);
+ p2 = initial.opStringSeqOpt(p1, p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ Ice.AsyncResult r = initial.begin_opStringSeqOpt(p1);
+ p2 = initial.end_opStringSeqOpt(p3, r);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ p2 = initial.opStringSeq(p1.get(), p3);
+ test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+ r = initial.begin_opStringSeq(p1.get());
+ p2 = initial.end_opStringSeq(p3, r);
test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
- p2 = initial.opStringSeq(new Ice.Optional<String[]>(), p3);
+ p2 = initial.opStringSeqOpt(new Ice.Optional<String[]>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -823,9 +1478,127 @@ public class AllTests
}
{
+ Ice.Optional<SmallStruct[]> p1 = new Ice.Optional<SmallStruct[]>();
+ Ice.Optional<SmallStruct[]> p3 = new Ice.Optional<SmallStruct[]>();
+ Ice.Optional<SmallStruct[]> p2 = initial.opSmallStructSeqOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new SmallStruct[10]);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ p1.get()[i] = new SmallStruct();
+ }
+ p2 = initial.opSmallStructSeqOpt(p1, p3);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ Ice.AsyncResult r = initial.begin_opSmallStructSeqOpt(p1);
+ p2 = initial.end_opSmallStructSeqOpt(p3, r);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ p2 = initial.opSmallStructSeq(p1.get(), p3);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ r = initial.begin_opSmallStructSeq(p1.get());
+ p2 = initial.end_opSmallStructSeq(p3, r);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+
+ p2 = initial.opSmallStructSeqOpt(new Ice.Optional<SmallStruct[]>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(p1.get().length + (p1.get().length > 254 ? 5 : 1));
+ SmallStructSeqHelper.write(os, p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opSmallStructSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ SmallStruct[] arr = SmallStructSeqHelper.read(in);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(arr[i].equals(p1.get()[i]));
+ }
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ arr = SmallStructSeqHelper.read(in);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(arr[i].equals(p1.get()[i]));
+ }
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<java.util.List<SmallStruct>> p1 = new Ice.Optional<java.util.List<SmallStruct>>();
+ Ice.Optional<java.util.List<SmallStruct>> p3 = new Ice.Optional<java.util.List<SmallStruct>>();
+ Ice.Optional<java.util.List<SmallStruct>> p2 = initial.opSmallStructListOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new java.util.ArrayList<SmallStruct>());
+ for(int i = 0; i < 10; ++i)
+ {
+ p1.get().add(new SmallStruct());
+ }
+ p2 = initial.opSmallStructListOpt(p1, p3);
+ test(p2.get().equals(p1.get()));
+ Ice.AsyncResult r = initial.begin_opSmallStructListOpt(p1);
+ p2 = initial.end_opSmallStructListOpt(p3, r);
+ test(p2.get().equals(p1.get()));
+ p2 = initial.opSmallStructList(p1.get(), p3);
+ test(p2.get().equals(p1.get()));
+ r = initial.begin_opSmallStructList(p1.get());
+ p2 = initial.end_opSmallStructList(p3, r);
+ test(p2.get().equals(p1.get()));
+
+ p2 = initial.opSmallStructListOpt(new Ice.Optional<java.util.List<SmallStruct>>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(p1.get().size() + (p1.get().size() > 254 ? 5 : 1));
+ SmallStructListHelper.write(os, p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opSmallStructList", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ java.util.List<SmallStruct> arr = SmallStructListHelper.read(in);
+ test(arr.equals(p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ arr = SmallStructListHelper.read(in);
+ test(arr.equals(p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
Ice.Optional<FixedStruct[]> p1 = new Ice.Optional<FixedStruct[]>();
Ice.Optional<FixedStruct[]> p3 = new Ice.Optional<FixedStruct[]>();
- Ice.Optional<FixedStruct[]> p2 = initial.opFixedStructSeq(p1, p3);
+ Ice.Optional<FixedStruct[]> p2 = initial.opFixedStructSeqOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set(new FixedStruct[10]);
@@ -833,13 +1606,30 @@ public class AllTests
{
p1.get()[i] = new FixedStruct();
}
- p2 = initial.opFixedStructSeq(p1, p3);
+ p2 = initial.opFixedStructSeqOpt(p1, p3);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ Ice.AsyncResult r = initial.begin_opFixedStructSeqOpt(p1);
+ p2 = initial.end_opFixedStructSeqOpt(p3, r);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ p2 = initial.opFixedStructSeq(p1.get(), p3);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ r = initial.begin_opFixedStructSeq(p1.get());
+ p2 = initial.end_opFixedStructSeq(p3, r);
for(int i = 0; i < p1.get().length; ++i)
{
test(p2.get()[i].equals(p1.get()[i]));
}
- p2 = initial.opFixedStructSeq(new Ice.Optional<FixedStruct[]>(), p3);
+ p2 = initial.opFixedStructSeqOpt(new Ice.Optional<FixedStruct[]>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -874,9 +1664,59 @@ public class AllTests
}
{
+ Ice.Optional<java.util.List<FixedStruct>> p1 = new Ice.Optional<java.util.List<FixedStruct>>();
+ Ice.Optional<java.util.List<FixedStruct>> p3 = new Ice.Optional<java.util.List<FixedStruct>>();
+ Ice.Optional<java.util.List<FixedStruct>> p2 = initial.opFixedStructListOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new java.util.ArrayList<FixedStruct>());
+ for(int i = 0; i < 10; ++i)
+ {
+ p1.get().add(new FixedStruct());
+ }
+ p2 = initial.opFixedStructListOpt(p1, p3);
+ test(p2.get().equals(p1.get()));
+ Ice.AsyncResult r = initial.begin_opFixedStructListOpt(p1);
+ p2 = initial.end_opFixedStructListOpt(p3, r);
+ test(p2.get().equals(p1.get()));
+ p2 = initial.opFixedStructList(p1.get(), p3);
+ test(p2.get().equals(p1.get()));
+ r = initial.begin_opFixedStructList(p1.get());
+ p2 = initial.end_opFixedStructList(p3, r);
+ test(p2.get().equals(p1.get()));
+
+ p2 = initial.opFixedStructListOpt(new Ice.Optional<java.util.List<FixedStruct>>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(p1.get().size() * 4 + (p1.get().size() > 254 ? 5 : 1));
+ FixedStructListHelper.write(os, p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opFixedStructList", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ java.util.List<FixedStruct> arr = FixedStructListHelper.read(in);
+ test(arr.equals(p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ arr = FixedStructListHelper.read(in);
+ test(arr.equals(p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
Ice.Optional<VarStruct[]> p1 = new Ice.Optional<VarStruct[]>();
Ice.Optional<VarStruct[]> p3 = new Ice.Optional<VarStruct[]>();
- Ice.Optional<VarStruct[]> p2 = initial.opVarStructSeq(p1, p3);
+ Ice.Optional<VarStruct[]> p2 = initial.opVarStructSeqOpt(p1, p3);
test(!p2.isSet() && !p3.isSet());
p1.set(new VarStruct[10]);
@@ -884,13 +1724,30 @@ public class AllTests
{
p1.get()[i] = new VarStruct("");
}
- p2 = initial.opVarStructSeq(p1, p3);
+ p2 = initial.opVarStructSeqOpt(p1, p3);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ Ice.AsyncResult r = initial.begin_opVarStructSeqOpt(p1);
+ p2 = initial.end_opVarStructSeqOpt(p3, r);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ p2 = initial.opVarStructSeq(p1.get(), p3);
+ for(int i = 0; i < p1.get().length; ++i)
+ {
+ test(p2.get()[i].equals(p1.get()[i]));
+ }
+ r = initial.begin_opVarStructSeq(p1.get());
+ p2 = initial.end_opVarStructSeq(p3, r);
for(int i = 0; i < p1.get().length; ++i)
{
test(p2.get()[i].equals(p1.get()[i]));
}
- p2 = initial.opVarStructSeq(new Ice.Optional<VarStruct[]>(), p3);
+ p2 = initial.opVarStructSeqOpt(new Ice.Optional<VarStruct[]>(), p3);
test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
os = Ice.Util.createOutputStream(communicator);
@@ -924,6 +1781,146 @@ public class AllTests
in.startEncapsulation();
in.endEncapsulation();
}
+
+ {
+ Ice.Optional<SerializableClass> p1 = new Ice.Optional<SerializableClass>();
+ Ice.Optional<SerializableClass> p3 = new Ice.Optional<SerializableClass>();
+ Ice.Optional<SerializableClass> p2 = initial.opSerializableOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new SerializableClass(58));
+ p2 = initial.opSerializableOpt(p1, p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ Ice.AsyncResult r = initial.begin_opSerializableOpt(p1);
+ p2 = initial.end_opSerializableOpt(p3, r);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ p2 = initial.opSerializable(p1.get(), p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ r = initial.begin_opSerializable(p1.get());
+ p2 = initial.end_opSerializable(p3, r);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+
+ p2 = initial.opSerializableOpt(new Ice.Optional<SerializableClass>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSerializable(p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opSerializable", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ SerializableClass sc = SerializableHelper.read(in);
+ test(sc.equals(p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ sc = SerializableHelper.read(in);
+ test(sc.equals(p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<java.util.Map<Integer, Integer>> p1 = new Ice.Optional<java.util.Map<Integer, Integer>>();
+ Ice.Optional<java.util.Map<Integer, Integer>> p3 = new Ice.Optional<java.util.Map<Integer, Integer>>();
+ Ice.Optional<java.util.Map<Integer, Integer>> p2 = initial.opIntIntDictOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new java.util.HashMap<Integer, Integer>());
+ p1.get().put(1, 2);
+ p1.get().put(2, 3);
+ p2 = initial.opIntIntDictOpt(p1, p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ Ice.AsyncResult r = initial.begin_opIntIntDictOpt(p1);
+ p2 = initial.end_opIntIntDictOpt(p3, r);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ p2 = initial.opIntIntDict(p1.get(), p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ r = initial.begin_opIntIntDict(p1.get());
+ p2 = initial.end_opIntIntDict(p3, r);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+
+ p2 = initial.opIntIntDictOpt(new Ice.Optional<java.util.Map<Integer, Integer>>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.VSize);
+ os.writeSize(p1.get().size() * 8 + (p1.get().size() > 254 ? 5 : 1));
+ IntIntDictHelper.write(os, p1.get());
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opIntIntDict", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.VSize));
+ in.skipSize();
+ java.util.Map<Integer, Integer> m = IntIntDictHelper.read(in);
+ test(m.equals(p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.VSize));
+ in.skipSize();
+ m = IntIntDictHelper.read(in);
+ test(m.equals(p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
+
+ {
+ Ice.Optional<java.util.Map<String, Integer>> p1 = new Ice.Optional<java.util.Map<String, Integer>>();
+ Ice.Optional<java.util.Map<String, Integer>> p3 = new Ice.Optional<java.util.Map<String, Integer>>();
+ Ice.Optional<java.util.Map<String, Integer>> p2 = initial.opStringIntDictOpt(p1, p3);
+ test(!p2.isSet() && !p3.isSet());
+
+ p1.set(new java.util.HashMap<String, Integer>());
+ p1.get().put("1", 1);
+ p1.get().put("2", 2);
+ p2 = initial.opStringIntDictOpt(p1, p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ Ice.AsyncResult r = initial.begin_opStringIntDictOpt(p1);
+ p2 = initial.end_opStringIntDictOpt(p3, r);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ p2 = initial.opStringIntDict(p1.get(), p3);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+ r = initial.begin_opStringIntDict(p1.get());
+ p2 = initial.end_opStringIntDict(p3, r);
+ test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+
+ p2 = initial.opStringIntDictOpt(new Ice.Optional<java.util.Map<String, Integer>>(), p3);
+ test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
+
+ os = Ice.Util.createOutputStream(communicator);
+ os.startEncapsulation();
+ os.writeOptional(2, Ice.OptionalType.FSize);
+ os.startSize();
+ StringIntDictHelper.write(os, p1.get());
+ os.endSize();
+ os.endEncapsulation();
+ inEncaps = os.finished();
+ initial.ice_invoke("opStringIntDict", Ice.OperationMode.Normal, inEncaps, outEncaps);
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ test(in.readOptional(1, Ice.OptionalType.FSize));
+ in.skip(4);
+ java.util.Map<String, Integer> m = StringIntDictHelper.read(in);
+ test(m.equals(p1.get()));
+ test(in.readOptional(3, Ice.OptionalType.FSize));
+ in.skip(4);
+ m = StringIntDictHelper.read(in);
+ test(m.equals(p1.get()));
+ in.endEncapsulation();
+
+ in = Ice.Util.createInputStream(communicator, outEncaps.value);
+ in.startEncapsulation();
+ in.endEncapsulation();
+ }
out.println("ok");
out.print("testing exception optionals... ");
@@ -931,7 +1928,7 @@ public class AllTests
{
try
{
- Ice.Optional<Integer> a = new Ice.Optional<Integer>();
+ Ice.IntOptional a = new Ice.IntOptional();
Ice.Optional<String> b = new Ice.Optional<String>();
Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>();
initial.opOptionalException(a, b, o);
@@ -945,7 +1942,7 @@ public class AllTests
try
{
- Ice.Optional<Integer> a = new Ice.Optional<Integer>(30);
+ Ice.IntOptional a = new Ice.IntOptional(30);
Ice.Optional<String> b = new Ice.Optional<String>("test");
Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>(new OneOptional(53));
initial.opOptionalException(a, b, o);
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-03 22:10:07 +0000