clean up optional tests; bug fixes for Java/C#

1 files changed, 1125 insertions, 934 deletions

diff --git a/java/test/Ice/optional/AllTests.java b/java/test/Ice/optional/AllTests.java
index 92884078cb0..012d4e4f50a 100644
--- a/java/test/Ice/optional/AllTests.java
+++ b/java/test/Ice/optional/AllTests.java
@@ -101,6 +101,8 @@ public class AllTests
 
         mo1.setBos(new boolean[] { false, true, false });
 
+        mo1.setSer(new SerializableClass(58));
+
         test(mo1.getA() == (byte)15);
         test(mo1.getB());
         test(mo1.getC() == (short)19);
@@ -134,6 +136,8 @@ public class AllTests
 
         test(java.util.Arrays.equals(mo1.getBos(), new boolean[] { false, true, false }));
 
+        test(mo1.getSer().equals(new SerializableClass(58)));
+
         out.println("ok");
 
         out.print("testing marshaling... ");
@@ -179,6 +183,14 @@ public class AllTests
 
         test(!mo4.hasBos());
 
+        test(!mo4.hasSer());
+
+        final boolean supportsJavaSerializable = initial.supportsJavaSerializable();
+        if(!supportsJavaSerializable)
+        {
+            mo1.clearSer();
+        }
+
         MultiOptional mo5 = (MultiOptional)initial.pingPong(mo1);
         test(mo5.getA() == mo1.getA());
         test(mo5.getB() == mo1.getB());
@@ -212,6 +224,11 @@ public class AllTests
 
         test(java.util.Arrays.equals(mo5.getBos(), new boolean[] { false, true, false }));
 
+        if(supportsJavaSerializable)
+        {
+            test(mo5.getSer().equals(mo1.getSer()));
+        }
+
         // Clear the first half of the optional parameters
         MultiOptional mo6 = new MultiOptional();
         mo6.setB(mo5.getB());
@@ -319,15 +336,15 @@ public class AllTests
 
         {
             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);
+            java.util.ArrayList<SmallStruct> l = new java.util.ArrayList<SmallStruct>();
+            l.add(new SmallStruct((byte)5));
+            l.add(new SmallStruct((byte)6));
+            l.add(new SmallStruct((byte)7));
+            owc1.setL(l);
             owc1.setS(new ClassVarStruct(5));
             OptionalWithCustom owc2 = (OptionalWithCustom)initial.pingPong(owc1);
-            test(owc2.hasBs());
-            test(owc2.getBs().equals(l));
+            test(owc2.hasL());
+            test(owc2.getL().equals(l));
             test(owc2.hasS());
             test(owc2.getS().a == 5);
         }
@@ -523,964 +540,1033 @@ public class AllTests
 
         out.print("testing optional parameters... ");
         out.flush();
+        final boolean reqParams = initial.supportsRequiredParams();
+
         {
+
             Ice.ByteOptional p1 = new Ice.ByteOptional();
             Ice.ByteOptional p3 = new Ice.ByteOptional();
-            Ice.ByteOptional p2 = initial.opByteOpt(p1, p3);
+            Ice.ByteOptional p2 = initial.opByte(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set((byte)56);
-            p2 = initial.opByteOpt(p1, p3);
+            p2 = initial.opByte(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());
+            Ice.AsyncResult r = initial.begin_opByte(p1);
             p2 = initial.end_opByte(p3, r);
             test(p2.get() == (byte)56 && p3.get() == (byte)56);
-
-            p2 = initial.opByteOpt(new Ice.ByteOptional(), p3);
+            p2 = initial.opByte(new Ice.ByteOptional(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(2, Ice.OptionalFormat.F1);
-            os.writeByte(p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opByte", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.F1));
-            test(in.readByte() == (byte)56);
-            test(in.readOptional(3, Ice.OptionalFormat.F1));
-            test(in.readByte() == (byte)56);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opByteReq(p1.get(), p3);
+                test(p2.get() == (byte)56 && p3.get() == (byte)56);
+                r = initial.begin_opByteReq(p1.get());
+                p2 = initial.end_opByteReq(p3, r);
+                test(p2.get() == (byte)56 && p3.get() == (byte)56);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.F1);
+                os.writeByte(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opByteReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.F1));
+                test(in.readByte() == (byte)56);
+                test(in.readOptional(3, Ice.OptionalFormat.F1));
+                test(in.readByte() == (byte)56);
+                in.endEncapsulation();
+
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                in.endEncapsulation();
+            }
         }
 
         {
             Ice.BooleanOptional p1 = new Ice.BooleanOptional();
             Ice.BooleanOptional p3 = new Ice.BooleanOptional();
-            Ice.BooleanOptional p2 = initial.opBoolOpt(p1, p3);
+            Ice.BooleanOptional p2 = initial.opBool(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);
+            p2 = initial.opBool(p1, p3);
             test(p2.get() == true && p3.get() == true);
-            r = initial.begin_opBool(true);
+            Ice.AsyncResult r = initial.begin_opBool(p1);
             p2 = initial.end_opBool(p3, r);
             test(p2.get() == true && p3.get() == true);
-
-            p2 = initial.opBoolOpt(new Ice.BooleanOptional(), p3);
+            p2 = initial.opBool(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.OptionalFormat.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.OptionalFormat.F1));
-            test(in.readBool() == true);
-            test(in.readOptional(3, Ice.OptionalFormat.F1));
-            test(in.readBool() == true);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opBoolReq(true, p3);
+                test(p2.get() == true && p3.get() == true);
+                r = initial.begin_opBoolReq(true);
+                p2 = initial.end_opBoolReq(p3, r);
+                test(p2.get() == true && p3.get() == true);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.F1);
+                os.writeBool(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opBoolReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.F1));
+                test(in.readBool() == true);
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.ShortOptional p2 = initial.opShort(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set((short)56);
-            p2 = initial.opShortOpt(p1, p3);
+            p2 = initial.opShort(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());
+            Ice.AsyncResult r = initial.begin_opShort(p1);
             p2 = initial.end_opShort(p3, r);
             test(p2.get() == 56 && p3.get() == 56);
-
-            p2 = initial.opShortOpt(new Ice.ShortOptional(), p3);
+            p2 = initial.opShort(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.OptionalFormat.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.OptionalFormat.F2));
-            test(in.readShort() == 56);
-            test(in.readOptional(3, Ice.OptionalFormat.F2));
-            test(in.readShort() == 56);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opShortReq(p1.get(), p3);
+                test(p2.get() == 56 && p3.get() == 56);
+                r = initial.begin_opShortReq(p1.get());
+                p2 = initial.end_opShortReq(p3, r);
+                test(p2.get() == 56 && p3.get() == 56);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.F2);
+                os.writeShort(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opShortReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.F2));
+                test(in.readShort() == 56);
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.IntOptional p2 = initial.opInt(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);
+            p2 = initial.opInt(p1, p3);
             test(p2.get() == 56 && p3.get() == 56);
-            r = initial.begin_opInt(p1.get());
+            Ice.AsyncResult r = initial.begin_opInt(p1);
             p2 = initial.end_opInt(p3, r);
             test(p2.get() == 56 && p3.get() == 56);
-
-            p2 = initial.opIntOpt(new Ice.IntOptional(), p3);
+            p2 = initial.opInt(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.OptionalFormat.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.OptionalFormat.F4));
-            test(in.readInt() == 56);
-            test(in.readOptional(3, Ice.OptionalFormat.F4));
-            test(in.readInt() == 56);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opIntReq(p1.get(), p3);
+                test(p2.get() == 56 && p3.get() == 56);
+                r = initial.begin_opIntReq(p1.get());
+                p2 = initial.end_opIntReq(p3, r);
+                test(p2.get() == 56 && p3.get() == 56);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.F4);
+                os.writeInt(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opIntReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.F4));
+                test(in.readInt() == 56);
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.LongOptional p2 = initial.opLong(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             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);
+            p2 = initial.opLong(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opLong(p1);
             p2 = initial.end_opLong(p3, r);
             test(p2.get() == 56 && p3.get() == 56);
-
-            p2 = initial.opLongOpt(new Ice.LongOptional(), p3);
+            p2 = initial.opLong(new Ice.LongOptional(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(1, Ice.OptionalFormat.F8);
-            os.writeLong(p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opLong", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(2, Ice.OptionalFormat.F8));
-            test(in.readLong() == 56);
-            test(in.readOptional(3, Ice.OptionalFormat.F8));
-            test(in.readLong() == 56);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opLongReq(p1.get(), p3);
+                test(p2.get() == 56 && p3.get() == 56);
+                r = initial.begin_opLongReq(p1.get());
+                p2 = initial.end_opLongReq(p3, r);
+                test(p2.get() == 56 && p3.get() == 56);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(1, Ice.OptionalFormat.F8);
+                os.writeLong(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opLongReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(2, Ice.OptionalFormat.F8));
+                test(in.readLong() == 56);
+                test(in.readOptional(3, Ice.OptionalFormat.F8));
+                test(in.readLong() == 56);
+                in.endEncapsulation();
+
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                in.endEncapsulation();
+            }
         }
 
         {
             Ice.FloatOptional p1 = new Ice.FloatOptional();
             Ice.FloatOptional p3 = new Ice.FloatOptional();
-            Ice.FloatOptional p2 = initial.opFloatOpt(p1, p3);
+            Ice.FloatOptional p2 = initial.opFloat(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);
+            p2 = initial.opFloat(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opFloat(p1);
             p2 = initial.end_opFloat(p3, r);
             test(p2.get() == 1.0 && p3.get() == 1.0);
-
-            p2 = initial.opFloatOpt(new Ice.FloatOptional(), p3);
+            p2 = initial.opFloat(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.OptionalFormat.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.OptionalFormat.F4));
-            test(in.readFloat() == 1.0);
-            test(in.readOptional(3, Ice.OptionalFormat.F4));
-            test(in.readFloat() == 1.0);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opFloatReq(p1.get(), p3);
+                test(p2.get() == 1.0 && p3.get() == 1.0);
+                r = initial.begin_opFloatReq(p1.get());
+                p2 = initial.end_opFloatReq(p3, r);
+                test(p2.get() == 1.0 && p3.get() == 1.0);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.F4);
+                os.writeFloat(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opFloatReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.F4));
+                test(in.readFloat() == 1.0);
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.DoubleOptional p2 = initial.opDouble(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);
+            p2 = initial.opDouble(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opDouble(p1);
             p2 = initial.end_opDouble(p3, r);
             test(p2.get() == 1.0 && p3.get() == 1.0);
-
-            p2 = initial.opDoubleOpt(new Ice.DoubleOptional(), p3);
+            p2 = initial.opDouble(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.OptionalFormat.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.OptionalFormat.F8));
-            test(in.readDouble() == 1.0);
-            test(in.readOptional(3, Ice.OptionalFormat.F8));
-            test(in.readDouble() == 1.0);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opDoubleReq(p1.get(), p3);
+                test(p2.get() == 1.0 && p3.get() == 1.0);
+                r = initial.begin_opDoubleReq(p1.get());
+                p2 = initial.end_opDoubleReq(p3, r);
+                test(p2.get() == 1.0 && p3.get() == 1.0);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.F8);
+                os.writeDouble(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opDoubleReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.F8));
+                test(in.readDouble() == 1.0);
+                test(in.readOptional(3, Ice.OptionalFormat.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.opStringOpt(p1, p3);
+            Ice.Optional<String> p2 = initial.opString(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set("test");
-            p2 = initial.opStringOpt(p1, p3);
+            p2 = initial.opString(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());
+            Ice.AsyncResult r = initial.begin_opString(p1);
             p2 = initial.end_opString(p3, r);
             test(p2.get().equals("test") && p3.get().equals("test"));
-
-            p2 = initial.opStringOpt(new Ice.Optional<String>(), p3);
+            p2 = initial.opString(new Ice.Optional<String>(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(2, Ice.OptionalFormat.VSize);
-            os.writeString(p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opString", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.VSize));
-            test(in.readString().equals("test"));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            test(in.readString().equals("test"));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opStringReq(p1.get(), p3);
+                test(p2.get().equals("test") && p3.get().equals("test"));
+                r = initial.begin_opStringReq(p1.get());
+                p2 = initial.end_opStringReq(p3, r);
+                test(p2.get().equals("test") && p3.get().equals("test"));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeString(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opStringReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                test(in.readString().equals("test"));
+                test(in.readOptional(3, Ice.OptionalFormat.VSize));
+                test(in.readString().equals("test"));
+                in.endEncapsulation();
+
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                in.endEncapsulation();
+            }
         }
 
         {
             Ice.Optional<MyEnum> p1 = new Ice.Optional<MyEnum>();
             Ice.Optional<MyEnum> p3 = new Ice.Optional<MyEnum>();
-            Ice.Optional<MyEnum> p2 = initial.opMyEnumOpt(p1, p3);
+            Ice.Optional<MyEnum> p2 = initial.opMyEnum(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);
+            p2 = initial.opMyEnum(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opMyEnum(p1);
             p2 = initial.end_opMyEnum(p3, r);
             test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
-
-            p2 = initial.opMyEnumOpt(new Ice.Optional<MyEnum>(), p3);
+            p2 = initial.opMyEnum(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.OptionalFormat.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.OptionalFormat.Size));
-            test(MyEnum.ice_read(in) == MyEnum.MyEnumMember);
-            test(in.readOptional(3, Ice.OptionalFormat.Size));
-            test(MyEnum.ice_read(in) == MyEnum.MyEnumMember);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opMyEnumReq(p1.get(), p3);
+                test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
+                r = initial.begin_opMyEnumReq(p1.get());
+                p2 = initial.end_opMyEnumReq(p3, r);
+                test(p2.get() == MyEnum.MyEnumMember && p3.get() == MyEnum.MyEnumMember);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.Size);
+                p1.get().ice_write(os);
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opMyEnumReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.Size));
+                test(MyEnum.ice_read(in) == MyEnum.MyEnumMember);
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.Optional<SmallStruct> p2 = initial.opSmallStruct(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);
+            p2 = initial.opSmallStruct(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opSmallStruct(p1);
             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);
+            p2 = initial.opSmallStruct(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            SmallStruct f = new SmallStruct();
-            f.ice_read(in);
-            test(f.m == (byte)56);
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            f.ice_read(in);
-            test(f.m == (byte)56);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opSmallStructReq(p1.get(), p3);
+                test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
+                r = initial.begin_opSmallStructReq(p1.get());
+                p2 = initial.end_opSmallStructReq(p3, r);
+                test(p2.get().m == (byte)56 && p3.get().m == (byte)56);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeSize(1);
+                p1.get().ice_write(os);
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opSmallStructReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                SmallStruct f = new SmallStruct();
+                f.ice_read(in);
+                test(f.m == (byte)56);
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.Optional<FixedStruct> p2 = initial.opFixedStruct(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);
+            p2 = initial.opFixedStruct(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opFixedStruct(p1);
             p2 = initial.end_opFixedStruct(p3, r);
             test(p2.get().m == 56 && p3.get().m == 56);
-
-            p2 = initial.opFixedStructOpt(new Ice.Optional<FixedStruct>(), p3);
+            p2 = initial.opFixedStruct(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            FixedStruct f = new FixedStruct();
-            f.ice_read(in);
-            test(f.m == 56);
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            f.ice_read(in);
-            test(f.m == 56);
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opFixedStructReq(p1.get(), p3);
+                test(p2.get().m == 56 && p3.get().m == 56);
+                r = initial.begin_opFixedStructReq(p1.get());
+                p2 = initial.end_opFixedStructReq(p3, r);
+                test(p2.get().m == 56 && p3.get().m == 56);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeSize(4);
+                p1.get().ice_write(os);
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opFixedStructReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                FixedStruct f = new FixedStruct();
+                f.ice_read(in);
+                test(f.m == 56);
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.Optional<VarStruct> p2 = initial.opVarStruct(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new VarStruct("test"));
-            p2 = initial.opVarStructOpt(p1, p3);
+            p2 = initial.opVarStruct(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());
+            Ice.AsyncResult r = initial.begin_opVarStruct(p1);
             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);
+            p2 = initial.opVarStruct(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.OptionalFormat.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.OptionalFormat.FSize));
-            in.skip(4);
-            VarStruct v = new VarStruct();
-            v.ice_read(in);
-            test(v.m.equals("test"));
-            test(in.readOptional(3, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            v.ice_read(in);
-            test(v.m.equals("test"));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opVarStructReq(p1.get(), p3);
+                test(p2.get().m.equals("test") && p3.get().m.equals("test"));
+                r = initial.begin_opVarStructReq(p1.get());
+                p2 = initial.end_opVarStructReq(p3, r);
+                test(p2.get().m.equals("test") && p3.get().m.equals("test"));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.FSize);
+                os.startSize();
+                p1.get().ice_write(os);
+                os.endSize();
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opVarStructReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                VarStruct v = new VarStruct();
+                v.ice_read(in);
+                test(v.m.equals("test"));
+                test(in.readOptional(3, Ice.OptionalFormat.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.opOneOptionalOpt(p1, p3);
+            Ice.Optional<OneOptional> p2 = initial.opOneOptional(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new OneOptional(58));
-            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);
+            p2 = initial.opOneOptional(p1, p3);
             test(p2.get().getA() == 58 && p3.get().getA() == 58);
-            r = initial.begin_opOneOptional(p1.get());
+            Ice.AsyncResult r = initial.begin_opOneOptional(p1);
             p2 = initial.end_opOneOptional(p3, r);
             test(p2.get().getA() == 58 && p3.get().getA() == 58);
-
-            p2 = initial.opOneOptionalOpt(new Ice.Optional<OneOptional>(), p3);
+            p2 = initial.opOneOptional(new Ice.Optional<OneOptional>(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(2, Ice.OptionalFormat.Size);
-            os.writeObject(p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opOneOptional", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.Size));
-            ReadObjectCallbackI p2cb = new ReadObjectCallbackI();
-            in.readObject(p2cb);
-            test(in.readOptional(3, Ice.OptionalFormat.Size));
-            ReadObjectCallbackI p3cb = new ReadObjectCallbackI();
-            in.readObject(p3cb);
-            in.endEncapsulation();
-            test(((OneOptional)p2cb.obj).getA() == 58 && ((OneOptional)p3cb.obj).getA() == 58);
+            if(reqParams)
+            {
+                p2 = initial.opOneOptionalReq(p1.get(), p3);
+                test(p2.get().getA() == 58 && p3.get().getA() == 58);
+                r = initial.begin_opOneOptionalReq(p1.get());
+                p2 = initial.end_opOneOptionalReq(p3, r);
+                test(p2.get().getA() == 58 && p3.get().getA() == 58);
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.Size);
+                os.writeObject(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opOneOptionalReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.Size));
+                ReadObjectCallbackI p2cb = new ReadObjectCallbackI();
+                in.readObject(p2cb);
+                test(in.readOptional(3, Ice.OptionalFormat.Size));
+                ReadObjectCallbackI p3cb = new ReadObjectCallbackI();
+                in.readObject(p3cb);
+                in.endEncapsulation();
+                test(((OneOptional)p2cb.obj).getA() == 58 && ((OneOptional)p3cb.obj).getA() == 58);
+
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                in.endEncapsulation();
+            }
         }
 
         {
             Ice.Optional<OneOptionalPrx> p1 = new Ice.Optional<OneOptionalPrx>();
             Ice.Optional<OneOptionalPrx> p3 = new Ice.Optional<OneOptionalPrx>();
-            Ice.Optional<OneOptionalPrx> p2 = initial.opOneOptionalProxyOpt(p1, p3);
+            Ice.Optional<OneOptionalPrx> p2 = initial.opOneOptionalProxy(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(OneOptionalPrxHelper.uncheckedCast(communicator.stringToProxy("test")));
-            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);
+            p2 = initial.opOneOptionalProxy(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opOneOptionalProxy(p1);
             p2 = initial.end_opOneOptionalProxy(p3, r);
             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
-
-            p2 = initial.opOneOptionalProxyOpt(new Ice.Optional<OneOptionalPrx>(), p3);
+            p2 = initial.opOneOptionalProxy(new Ice.Optional<OneOptionalPrx>(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(2, Ice.OptionalFormat.FSize);
-            os.startSize();
-            os.writeProxy(p1.get());
-            os.endSize();
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opOneOptionalProxy", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            test(in.readProxy().equals(p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            test(in.readProxy().equals(p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opOneOptionalProxyReq(p1.get(), p3);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+                r = initial.begin_opOneOptionalProxyReq(p1.get());
+                p2 = initial.end_opOneOptionalProxyReq(p3, r);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.FSize);
+                os.startSize();
+                os.writeProxy(p1.get());
+                os.endSize();
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opOneOptionalProxyReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                test(in.readProxy().equals(p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                test(in.readProxy().equals(p1.get()));
+                in.endEncapsulation();
+
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                in.endEncapsulation();
+            }
         }
 
         {
             Ice.Optional<byte[]> p1 = new Ice.Optional<byte[]>();
             Ice.Optional<byte[]> p3 = new Ice.Optional<byte[]>();
-            Ice.Optional<byte[]> p2 = initial.opByteSeqOpt(p1, p3);
+            Ice.Optional<byte[]> p2 = initial.opByteSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new byte[100]);
             java.util.Arrays.fill(p1.get(), (byte)56);
-            p2 = initial.opByteSeqOpt(p1, p3);
+            p2 = initial.opByteSeq(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());
+            Ice.AsyncResult r = initial.begin_opByteSeq(p1);
             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.opByteSeqOpt(new Ice.Optional<byte[]>(), p3);
+            p2 = initial.opByteSeq(new Ice.Optional<byte[]>(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(2, Ice.OptionalFormat.VSize);
-            os.writeByteSeq(p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opByteSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.VSize));
-            test(java.util.Arrays.equals(in.readByteSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            test(java.util.Arrays.equals(in.readByteSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opByteSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opByteSeqReq(p1.get());
+                p2 = initial.end_opByteSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeByteSeq(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opByteSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                test(java.util.Arrays.equals(in.readByteSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.VSize));
+                test(java.util.Arrays.equals(in.readByteSeq(), p1.get()));
+                in.endEncapsulation();
+
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                in.endEncapsulation();
+            }
         }
 
         {
             Ice.Optional<boolean[]> p1 = new Ice.Optional<boolean[]>();
             Ice.Optional<boolean[]> p3 = new Ice.Optional<boolean[]>();
-            Ice.Optional<boolean[]> p2 = initial.opBoolSeqOpt(p1, p3);
+            Ice.Optional<boolean[]> p2 = initial.opBoolSeq(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);
+            p2 = initial.opBoolSeq(p1, p3);
             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
-            r = initial.begin_opBoolSeq(p1.get());
+            Ice.AsyncResult r = initial.begin_opBoolSeq(p1);
             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);
+            p2 = initial.opBoolSeq(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.OptionalFormat.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.OptionalFormat.VSize));
-            test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opBoolSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opBoolSeqReq(p1.get());
+                p2 = initial.end_opBoolSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeBoolSeq(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opBoolSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                test(java.util.Arrays.equals(in.readBoolSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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.opShortSeqOpt(p1, p3);
+            Ice.Optional<short[]> p2 = initial.opShortSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new short[100]);
             java.util.Arrays.fill(p1.get(), (short)56);
-            p2 = initial.opShortSeqOpt(p1, p3);
+            p2 = initial.opShortSeq(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());
+            Ice.AsyncResult r = initial.begin_opShortSeq(p1);
             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.opShortSeqOpt(new Ice.Optional<short[]>(), p3);
+            p2 = initial.opShortSeq(new Ice.Optional<short[]>(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(2, Ice.OptionalFormat.VSize);
-            os.writeSize(p1.get().length * 2 + (p1.get().length > 254 ? 5 : 1));
-            os.writeShortSeq(p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opShortSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readShortSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readShortSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opShortSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opShortSeqReq(p1.get());
+                p2 = initial.end_opShortSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeSize(p1.get().length * 2 + (p1.get().length > 254 ? 5 : 1));
+                os.writeShortSeq(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opShortSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                test(java.util.Arrays.equals(in.readShortSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                test(java.util.Arrays.equals(in.readShortSeq(), p1.get()));
+                in.endEncapsulation();
+
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                in.endEncapsulation();
+            }
         }
 
         {
             Ice.Optional<int[]> p1 = new Ice.Optional<int[]>();
             Ice.Optional<int[]> p3 = new Ice.Optional<int[]>();
-            Ice.Optional<int[]> p2 = initial.opIntSeqOpt(p1, p3);
+            Ice.Optional<int[]> p2 = initial.opIntSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             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);
+            p2 = initial.opIntSeq(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opIntSeq(p1);
             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.opIntSeqOpt(new Ice.Optional<int[]>(), p3);
+            p2 = initial.opIntSeq(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.OptionalFormat.VSize);
-            os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
-            os.writeIntSeq(p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opIntSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readIntSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readIntSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opIntSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opIntSeqReq(p1.get());
+                p2 = initial.end_opIntSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
+                os.writeIntSeq(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opIntSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                test(java.util.Arrays.equals(in.readIntSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.VSize));
+                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);
+            Ice.Optional<long[]> p2 = initial.opLongSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new long[100]);
             java.util.Arrays.fill(p1.get(), 56);
-            p2 = initial.opLongSeqOpt(p1, p3);
+            p2 = initial.opLongSeq(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());
+            Ice.AsyncResult r = initial.begin_opLongSeq(p1);
             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);
+            p2 = initial.opLongSeq(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readLongSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readLongSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opLongSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opLongSeqReq(p1.get());
+                p2 = initial.end_opLongSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.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("opLongSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                test(java.util.Arrays.equals(in.readLongSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.Optional<float[]> p2 = initial.opFloatSeq(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);
+            p2 = initial.opFloatSeq(p1, p3);
             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
-            r = initial.begin_opFloatSeq(p1.get());
+            Ice.AsyncResult r = initial.begin_opFloatSeq(p1);
             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);
+            p2 = initial.opFloatSeq(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readFloatSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readFloatSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opFloatSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opFloatSeqReq(p1.get());
+                p2 = initial.end_opFloatSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.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("opFloatSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                test(java.util.Arrays.equals(in.readFloatSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.Optional<double[]> p2 = initial.opDoubleSeq(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);
+            p2 = initial.opDoubleSeq(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());
+            Ice.AsyncResult r = initial.begin_opDoubleSeq(p1);
             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);
+            p2 = initial.opDoubleSeq(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opDoubleSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opDoubleSeqReq(p1.get());
+                p2 = initial.end_opDoubleSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.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("opDoubleSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                test(java.util.Arrays.equals(in.readDoubleSeq(), p1.get()));
+                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.opStringSeqOpt(p1, p3);
+            Ice.Optional<String[]> p2 = initial.opStringSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new String[10]);
             java.util.Arrays.fill(p1.get(), "test1");
-            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);
+            p2 = initial.opStringSeq(p1, p3);
             test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
-            r = initial.begin_opStringSeq(p1.get());
+            Ice.AsyncResult r = initial.begin_opStringSeq(p1);
             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.opStringSeqOpt(new Ice.Optional<String[]>(), p3);
+            p2 = initial.opStringSeq(new Ice.Optional<String[]>(), p3);
             test(!p2.isSet() && !p3.isSet()); // Ensure out parameter is cleared.
 
-            os = Ice.Util.createOutputStream(communicator);
-            os.startEncapsulation();
-            os.writeOptional(2, Ice.OptionalFormat.FSize);
-            os.startSize();
-            os.writeStringSeq(p1.get());
-            os.endSize();
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opStringSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            test(java.util.Arrays.equals(in.readStringSeq(), p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            test(java.util.Arrays.equals(in.readStringSeq(), p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opStringSeqReq(p1.get(), p3);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
+                r = initial.begin_opStringSeqReq(p1.get());
+                p2 = initial.end_opStringSeqReq(p3, r);
+                test(java.util.Arrays.equals(p2.get(), p1.get()) && java.util.Arrays.equals(p3.get(), p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.FSize);
+                os.startSize();
+                os.writeStringSeq(p1.get());
+                os.endSize();
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opStringSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                test(java.util.Arrays.equals(in.readStringSeq(), p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                test(java.util.Arrays.equals(in.readStringSeq(), p1.get()));
+                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.opSmallStructSeqOpt(p1, p3);
+            Ice.Optional<SmallStruct[]> p2 = initial.opSmallStructSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new SmallStruct[10]);
@@ -1488,67 +1574,70 @@ public class AllTests
             {
                 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);
+            p2 = initial.opSmallStructSeq(p1, p3);
             for(int i = 0; i < p1.get().length; ++i)
             {
                 test(p2.get()[i].equals(p1.get()[i]));
             }
-            r = initial.begin_opSmallStructSeq(p1.get());
+            Ice.AsyncResult r = initial.begin_opSmallStructSeq(p1);
             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);
+            p2 = initial.opSmallStructSeq(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.OptionalFormat.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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            arr = SmallStructSeqHelper.read(in);
-            for(int i = 0; i < p1.get().length; ++i)
+            if(reqParams)
             {
-                test(arr[i].equals(p1.get()[i]));
-            }
-            in.endEncapsulation();
+                p2 = initial.opSmallStructSeqReq(p1.get(), p3);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(p2.get()[i].equals(p1.get()[i]));
+                }
+                r = initial.begin_opSmallStructSeqReq(p1.get());
+                p2 = initial.end_opSmallStructSeqReq(p3, r);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(p2.get()[i].equals(p1.get()[i]));
+                }
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.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("opSmallStructSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.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.OptionalFormat.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);
+            Ice.Optional<java.util.List<SmallStruct>> p2 = initial.opSmallStructList(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new java.util.ArrayList<SmallStruct>());
@@ -1556,49 +1645,52 @@ public class AllTests
             {
                 p1.get().add(new SmallStruct());
             }
-            p2 = initial.opSmallStructListOpt(p1, p3);
+            p2 = initial.opSmallStructList(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());
+            Ice.AsyncResult r = initial.begin_opSmallStructList(p1);
             p2 = initial.end_opSmallStructList(p3, r);
             test(p2.get().equals(p1.get()));
-
-            p2 = initial.opSmallStructListOpt(new Ice.Optional<java.util.List<SmallStruct>>(), p3);
+            p2 = initial.opSmallStructList(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            java.util.List<SmallStruct> arr = SmallStructListHelper.read(in);
-            test(arr.equals(p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            arr = SmallStructListHelper.read(in);
-            test(arr.equals(p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opSmallStructListReq(p1.get(), p3);
+                test(p2.get().equals(p1.get()));
+                r = initial.begin_opSmallStructListReq(p1.get());
+                p2 = initial.end_opSmallStructListReq(p3, r);
+                test(p2.get().equals(p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.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("opSmallStructListReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                java.util.List<SmallStruct> arr = SmallStructListHelper.read(in);
+                test(arr.equals(p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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.opFixedStructSeqOpt(p1, p3);
+            Ice.Optional<FixedStruct[]> p2 = initial.opFixedStructSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new FixedStruct[10]);
@@ -1606,67 +1698,70 @@ public class AllTests
             {
                 p1.get()[i] = new FixedStruct();
             }
-            p2 = initial.opFixedStructSeqOpt(p1, p3);
+            p2 = initial.opFixedStructSeq(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());
+            Ice.AsyncResult r = initial.begin_opFixedStructSeq(p1);
             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.opFixedStructSeqOpt(new Ice.Optional<FixedStruct[]>(), p3);
+            p2 = initial.opFixedStructSeq(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.OptionalFormat.VSize);
-            os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
-            FixedStructSeqHelper.write(os, p1.get());
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opFixedStructSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            FixedStruct[] arr = FixedStructSeqHelper.read(in);
-            for(int i = 0; i < p1.get().length; ++i)
-            {
-                test(arr[i].equals(p1.get()[i]));
-            }
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            arr = FixedStructSeqHelper.read(in);
-            for(int i = 0; i < p1.get().length; ++i)
+            if(reqParams)
             {
-                test(arr[i].equals(p1.get()[i]));
-            }
-            in.endEncapsulation();
+                p2 = initial.opFixedStructSeqReq(p1.get(), p3);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(p2.get()[i].equals(p1.get()[i]));
+                }
+                r = initial.begin_opFixedStructSeqReq(p1.get());
+                p2 = initial.end_opFixedStructSeqReq(p3, r);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(p2.get()[i].equals(p1.get()[i]));
+                }
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeSize(p1.get().length * 4 + (p1.get().length > 254 ? 5 : 1));
+                FixedStructSeqHelper.write(os, p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opFixedStructSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                FixedStruct[] arr = FixedStructSeqHelper.read(in);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(arr[i].equals(p1.get()[i]));
+                }
+                test(in.readOptional(3, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                arr = FixedStructSeqHelper.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<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);
+            Ice.Optional<java.util.List<FixedStruct>> p2 = initial.opFixedStructList(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new java.util.ArrayList<FixedStruct>());
@@ -1674,49 +1769,52 @@ public class AllTests
             {
                 p1.get().add(new FixedStruct());
             }
-            p2 = initial.opFixedStructListOpt(p1, p3);
+            p2 = initial.opFixedStructList(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());
+            Ice.AsyncResult r = initial.begin_opFixedStructList(p1);
             p2 = initial.end_opFixedStructList(p3, r);
             test(p2.get().equals(p1.get()));
-
-            p2 = initial.opFixedStructListOpt(new Ice.Optional<java.util.List<FixedStruct>>(), p3);
+            p2 = initial.opFixedStructList(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            java.util.List<FixedStruct> arr = FixedStructListHelper.read(in);
-            test(arr.equals(p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            arr = FixedStructListHelper.read(in);
-            test(arr.equals(p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opFixedStructListReq(p1.get(), p3);
+                test(p2.get().equals(p1.get()));
+                r = initial.begin_opFixedStructListReq(p1.get());
+                p2 = initial.end_opFixedStructListReq(p3, r);
+                test(p2.get().equals(p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.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("opFixedStructListReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                java.util.List<FixedStruct> arr = FixedStructListHelper.read(in);
+                test(arr.equals(p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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.opVarStructSeqOpt(p1, p3);
+            Ice.Optional<VarStruct[]> p2 = initial.opVarStructSeq(p1, p3);
             test(!p2.isSet() && !p3.isSet());
 
             p1.set(new VarStruct[10]);
@@ -1724,202 +1822,215 @@ public class AllTests
             {
                 p1.get()[i] = new VarStruct("");
             }
-            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);
+            p2 = initial.opVarStructSeq(p1, p3);
             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());
+            Ice.AsyncResult r = initial.begin_opVarStructSeq(p1);
             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.opVarStructSeqOpt(new Ice.Optional<VarStruct[]>(), p3);
+            p2 = initial.opVarStructSeq(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.OptionalFormat.FSize);
-            os.startSize();
-            VarStructSeqHelper.write(os, p1.get());
-            os.endSize();
-            os.endEncapsulation();
-            inEncaps = os.finished();
-            initial.ice_invoke("opVarStructSeq", Ice.OperationMode.Normal, inEncaps, outEncaps);
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            test(in.readOptional(1, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            VarStruct[] arr = VarStructSeqHelper.read(in);
-            for(int i = 0; i < p1.get().length; ++i)
+            if(reqParams)
             {
-                test(arr[i].equals(p1.get()[i]));
-            }
-            test(in.readOptional(3, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            arr = VarStructSeqHelper.read(in);
-            for(int i = 0; i < p1.get().length; ++i)
-            {
-                test(arr[i].equals(p1.get()[i]));
-            }
-            in.endEncapsulation();
+                p2 = initial.opVarStructSeqReq(p1.get(), p3);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(p2.get()[i].equals(p1.get()[i]));
+                }
+                r = initial.begin_opVarStructSeqReq(p1.get());
+                p2 = initial.end_opVarStructSeqReq(p3, r);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(p2.get()[i].equals(p1.get()[i]));
+                }
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.FSize);
+                os.startSize();
+                VarStructSeqHelper.write(os, p1.get());
+                os.endSize();
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opVarStructSeqReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                VarStruct[] arr = VarStructSeqHelper.read(in);
+                for(int i = 0; i < p1.get().length; ++i)
+                {
+                    test(arr[i].equals(p1.get()[i]));
+                }
+                test(in.readOptional(3, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                arr = VarStructSeqHelper.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();
+            }
         }
 
+        if(supportsJavaSerializable)
         {
             Ice.Optional<SerializableClass> p1 = new Ice.Optional<SerializableClass>();
             Ice.Optional<SerializableClass> p3 = new Ice.Optional<SerializableClass>();
-            Ice.Optional<SerializableClass> p2 = initial.opSerializableOpt(p1, p3);
+            Ice.Optional<SerializableClass> p2 = initial.opSerializable(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);
+            p2 = initial.opSerializable(p1, p3);
             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
-            r = initial.begin_opSerializable(p1.get());
+            Ice.AsyncResult r = initial.begin_opSerializable(p1);
             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);
+            p2 = initial.opSerializable(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.OptionalFormat.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.OptionalFormat.VSize));
-            SerializableClass sc = SerializableHelper.read(in);
-            test(sc.equals(p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            sc = SerializableHelper.read(in);
-            test(sc.equals(p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opSerializableReq(p1.get(), p3);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+                r = initial.begin_opSerializableReq(p1.get());
+                p2 = initial.end_opSerializableReq(p3, r);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.VSize);
+                os.writeSerializable(p1.get());
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opSerializableReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                SerializableClass sc = SerializableHelper.read(in);
+                test(sc.equals(p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.Optional<java.util.Map<Integer, Integer>> p2 = initial.opIntIntDict(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);
+            p2 = initial.opIntIntDict(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());
+            Ice.AsyncResult r = initial.begin_opIntIntDict(p1);
             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);
+            p2 = initial.opIntIntDict(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.OptionalFormat.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.OptionalFormat.VSize));
-            in.skipSize();
-            java.util.Map<Integer, Integer> m = IntIntDictHelper.read(in);
-            test(m.equals(p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.VSize));
-            in.skipSize();
-            m = IntIntDictHelper.read(in);
-            test(m.equals(p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opIntIntDictReq(p1.get(), p3);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+                r = initial.begin_opIntIntDictReq(p1.get());
+                p2 = initial.end_opIntIntDictReq(p3, r);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.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("opIntIntDictReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.VSize));
+                in.skipSize();
+                java.util.Map<Integer, Integer> m = IntIntDictHelper.read(in);
+                test(m.equals(p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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);
+            Ice.Optional<java.util.Map<String, Integer>> p2 = initial.opStringIntDict(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);
+            p2 = initial.opStringIntDict(p1, p3);
             test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
-            r = initial.begin_opStringIntDict(p1.get());
+            Ice.AsyncResult r = initial.begin_opStringIntDict(p1);
             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);
+            p2 = initial.opStringIntDict(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.OptionalFormat.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.OptionalFormat.FSize));
-            in.skip(4);
-            java.util.Map<String, Integer> m = StringIntDictHelper.read(in);
-            test(m.equals(p1.get()));
-            test(in.readOptional(3, Ice.OptionalFormat.FSize));
-            in.skip(4);
-            m = StringIntDictHelper.read(in);
-            test(m.equals(p1.get()));
-            in.endEncapsulation();
+            if(reqParams)
+            {
+                p2 = initial.opStringIntDictReq(p1.get(), p3);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
+                r = initial.begin_opStringIntDictReq(p1.get());
+                p2 = initial.end_opStringIntDictReq(p3, r);
+                test(p2.get().equals(p1.get()) && p3.get().equals(p1.get()));
 
-            in = Ice.Util.createInputStream(communicator, outEncaps.value);
-            in.startEncapsulation();
-            in.endEncapsulation();
+                os = Ice.Util.createOutputStream(communicator);
+                os.startEncapsulation();
+                os.writeOptional(2, Ice.OptionalFormat.FSize);
+                os.startSize();
+                StringIntDictHelper.write(os, p1.get());
+                os.endSize();
+                os.endEncapsulation();
+                inEncaps = os.finished();
+                initial.ice_invoke("opStringIntDictReq", Ice.OperationMode.Normal, inEncaps, outEncaps);
+                in = Ice.Util.createInputStream(communicator, outEncaps.value);
+                in.startEncapsulation();
+                test(in.readOptional(1, Ice.OptionalFormat.FSize));
+                in.skip(4);
+                java.util.Map<String, Integer> m = StringIntDictHelper.read(in);
+                test(m.equals(p1.get()));
+                test(in.readOptional(3, Ice.OptionalFormat.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");
 
@@ -1953,6 +2064,86 @@ public class AllTests
                 test(ex.getB().equals("test"));
                 test(ex.getO().getA() == 53);
             }
+
+            try
+            {
+                Ice.IntOptional a = new Ice.IntOptional();
+                Ice.Optional<String> b = new Ice.Optional<String>();
+                Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>();
+                initial.opDerivedException(a, b, o);
+            }
+            catch(DerivedException ex)
+            {
+                test(!ex.hasA());
+                test(!ex.hasB());
+                test(!ex.hasO());
+                test(!ex.hasSs());
+                test(!ex.hasO2());
+            }
+            catch(OptionalException ex)
+            {
+                test(false);
+            }
+
+            try
+            {
+                Ice.IntOptional a = new Ice.IntOptional(30);
+                Ice.Optional<String> b = new Ice.Optional<String>("test2");
+                Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>(new OneOptional(53));
+                initial.opDerivedException(a, b, o);
+            }
+            catch(DerivedException ex)
+            {
+                test(ex.getA() == 30);
+                test(ex.getB().equals("test2"));
+                test(ex.getO().getA() == 53);
+                test(ex.getSs().equals("test2"));
+                test(ex.getO2().getA() == 53);
+            }
+            catch(OptionalException ex)
+            {
+                test(false);
+            }
+
+            try
+            {
+                Ice.IntOptional a = new Ice.IntOptional();
+                Ice.Optional<String> b = new Ice.Optional<String>();
+                Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>();
+                initial.opRequiredException(a, b, o);
+            }
+            catch(RequiredException ex)
+            {
+                test(!ex.hasA());
+                test(!ex.hasB());
+                test(!ex.hasO());
+                test(ex.ss.equals("test"));
+                test(ex.o2 == null);
+            }
+            catch(OptionalException ex)
+            {
+                test(false);
+            }
+
+            try
+            {
+                Ice.IntOptional a = new Ice.IntOptional(30);
+                Ice.Optional<String> b = new Ice.Optional<String>("test2");
+                Ice.Optional<OneOptional> o = new Ice.Optional<OneOptional>(new OneOptional(53));
+                initial.opRequiredException(a, b, o);
+            }
+            catch(RequiredException ex)
+            {
+                test(ex.getA() == 30);
+                test(ex.getB().equals("test2"));
+                test(ex.getO().getA() == 53);
+                test(ex.ss.equals("test2"));
+                test(ex.o2.getA() == 53);
+            }
+            catch(OptionalException ex)
+            {
+                test(false);
+            }
         }
         out.println("ok");