Ruby port; Python & C++ fixes

3 files changed, 401 insertions, 49 deletions

diff --git a/cpp/test/Ice/optional/Test.ice b/cpp/test/Ice/optional/Test.ice
index ab306459ab1..4fcf2c6e092 100644
--- a/cpp/test/Ice/optional/Test.ice
+++ b/cpp/test/Ice/optional/Test.ice
@@ -24,9 +24,14 @@ enum MyEnum
     MyEnumMember
 };
 
+struct SmallStruct
+{
+    byte m;
+};
+
 struct FixedStruct
 {
-    int m; 
+    int m;
 };
 
 struct VarStruct
@@ -42,15 +47,22 @@ struct VarStruct
 sequence<byte> ByteSeq;
 sequence<bool> BoolSeq;
 sequence<short> ShortSeq;
+sequence<int> IntSeq;
+sequence<long> LongSeq;
+sequence<float> FloatSeq;
+sequence<double> DoubleSeq;
 sequence<string> StringSeq;
 sequence<MyEnum> MyEnumSeq;
+sequence<SmallStruct> SmallStructSeq;
+["cpp:type:std::list< ::Test::SmallStruct>"] sequence<SmallStruct> SmallStructList;
 sequence<FixedStruct> FixedStructSeq;
+["cpp:type:std::list< ::Test::FixedStruct>"] sequence<FixedStruct> FixedStructList;
 sequence<VarStruct> VarStructSeq;
 sequence<OneOptional> OneOptionalSeq;
 sequence<OneOptional*> OneOptionalPrxSeq;
 
-dictionary<int, int> IntIntDict; 
-dictionary<string, int> StringIntDict; 
+dictionary<int, int> IntIntDict;
+dictionary<string, int> StringIntDict;
 dictionary<int, MyEnum> IntEnumDict;
 dictionary<int, FixedStruct> IntFixedStructDict;
 dictionary<int, VarStruct> IntVarStructDict;
@@ -127,6 +139,18 @@ exception OptionalException
     optional(50) OneOptional o;
 };
 
+exception DerivedException extends OptionalException
+{
+    optional(600) string ss = "test";
+    optional(601) OneOptional o2;
+};
+
+exception RequiredException extends OptionalException
+{
+    string ss = "test";
+    OneOptional o2;
+};
+
 class OptionalWithCustom
 {
     ["cpp:type:std::list< ::Ice::Byte>"] optional(1) ByteSeq bs;
@@ -142,35 +166,84 @@ class Initial
     void opOptionalException(optional(1) int a, optional(2) string b, optional(3) OneOptional o)
         throws OptionalException;
 
+    void opDerivedException(optional(1) int a, optional(2) string b, optional(3) OneOptional o)
+        throws OptionalException;
+
+    void opRequiredException(optional(1) int a, optional(2) string b, optional(3) OneOptional o)
+        throws OptionalException;
+
     optional(1) byte opByte(optional(2) byte p1, out optional(3) byte p3);
 
+    optional(1) bool opBool(optional(2) bool p1, out optional(3) bool p3);
+
+    optional(1) short opShort(optional(2) short p1, out optional(3) short p3);
+
+    optional(1) int opInt(optional(2) int p1, out optional(3) int p3);
+
     optional(3) long opLong(optional(1) long p1, out optional(2) long p3);
 
+    optional(1) float opFloat(optional(2) float p1, out optional(3) float p3);
+
+    optional(1) double opDouble(optional(2) double p1, out optional(3) double p3);
+
     optional(1) string opString(optional(2) string p1, out optional(3) string p3);
 
+    optional(1) MyEnum opMyEnum(optional(2) MyEnum p1, out optional(3) MyEnum p3);
+
+    optional(1) SmallStruct opSmallStruct(optional(2) SmallStruct p1, out optional(3) SmallStruct p3);
+
+    optional(1) FixedStruct opFixedStruct(optional(2) FixedStruct p1, out optional(3) FixedStruct p3);
+
+    optional(1) VarStruct opVarStruct(optional(2) VarStruct p1, out optional(3) VarStruct p3);
+
     optional(1) OneOptional opOneOptional(optional(2) OneOptional p1, out optional(3) OneOptional p3);
 
     optional(1) OneOptional* opOneOptionalProxy(optional(2) OneOptional* p1, out optional(3) OneOptional* p3);
 
     // Custom mapping operations
-    ["cpp:array"] optional(1) ByteSeq opByteSeq(["cpp:array"] optional(2) ByteSeq p1, 
+    ["cpp:array"] optional(1) ByteSeq opByteSeq(["cpp:array"] optional(2) ByteSeq p1,
                                                 out ["cpp:array"] optional(3) ByteSeq p3);
 
-    ["cpp:array"] optional(1) ShortSeq opShortSeq(["cpp:array"] optional(2) ShortSeq p1, 
+    ["cpp:array"] optional(1) BoolSeq opBoolSeq(["cpp:array"] optional(2) BoolSeq p1,
+                                                out ["cpp:array"] optional(3) BoolSeq p3);
+
+    ["cpp:array"] optional(1) ShortSeq opShortSeq(["cpp:array"] optional(2) ShortSeq p1,
                                                   out ["cpp:array"] optional(3) ShortSeq p3);
 
-    ["cpp:range:array"] optional(1) BoolSeq opBoolSeq(["cpp:range:array"] optional(2) BoolSeq p1, 
-                                                      out ["cpp:range:array"] optional(3) BoolSeq p3);
+    ["cpp:range:array"] optional(1) IntSeq opIntSeq(["cpp:range:array"] optional(2) IntSeq p1,
+                                                    out ["cpp:range:array"] optional(3) IntSeq p3);
+
+    ["cpp:range:array"] optional(1) LongSeq opLongSeq(["cpp:range:array"] optional(2) LongSeq p1,
+                                                      out ["cpp:range:array"] optional(3) LongSeq p3);
 
-    ["cpp:range"] optional(1) StringSeq opStringSeq(["cpp:range"] optional(2) StringSeq p1, 
+    ["cpp:range:array"] optional(1) FloatSeq opFloatSeq(["cpp:range:array"] optional(2) FloatSeq p1,
+                                                        out ["cpp:range:array"] optional(3) FloatSeq p3);
+
+    ["cpp:range:array"] optional(1) DoubleSeq opDoubleSeq(["cpp:range:array"] optional(2) DoubleSeq p1,
+                                                          out ["cpp:range:array"] optional(3) DoubleSeq p3);
+
+    ["cpp:range"] optional(1) StringSeq opStringSeq(["cpp:range"] optional(2) StringSeq p1,
                                                     out ["cpp:range"] optional(3) StringSeq p3);
 
-    ["cpp:array"] optional(1) FixedStructSeq opFixedStructSeq(["cpp:array"] optional(2) FixedStructSeq p1, 
+    ["cpp:array"] optional(1) SmallStructSeq opSmallStructSeq(["cpp:array"] optional(2) SmallStructSeq p1,
+                                                              out ["cpp:array"] optional(3) SmallStructSeq p3);
+
+    ["cpp:array"] optional(1) SmallStructList opSmallStructList(["cpp:array"] optional(2) SmallStructList p1,
+                                                                out ["cpp:array"] optional(3) SmallStructList p3);
+
+    ["cpp:array"] optional(1) FixedStructSeq opFixedStructSeq(["cpp:array"] optional(2) FixedStructSeq p1,
                                                               out ["cpp:array"] optional(3) FixedStructSeq p3);
 
-    ["cpp:range"] optional(1) VarStructSeq opVarStructSeq(["cpp:range"] optional(2) VarStructSeq p1, 
+    ["cpp:array"] optional(1) FixedStructList opFixedStructList(["cpp:array"] optional(2) FixedStructList p1,
+                                                                out ["cpp:array"] optional(3) FixedStructList p3);
+
+    ["cpp:range"] optional(1) VarStructSeq opVarStructSeq(["cpp:range"] optional(2) VarStructSeq p1,
                                                           out ["cpp:range"] optional(3) VarStructSeq p3);
 
+    optional(1) IntIntDict opIntIntDict(optional(2) IntIntDict p1, out optional(3) IntIntDict p3);
+
+    optional(1) StringIntDict opStringIntDict(optional(2) StringIntDict p1, out optional(3) StringIntDict p3);
+
     void opClassAndUnknownOptional(A p);
 };
 
diff --git a/cpp/test/Ice/optional/TestI.cpp b/cpp/test/Ice/optional/TestI.cpp
index 22de9e2cb6e..826d0e9178c 100644
--- a/cpp/test/Ice/optional/TestI.cpp
+++ b/cpp/test/Ice/optional/TestI.cpp
@@ -44,6 +44,42 @@ InitialI::opOptionalException(const Optional<Int>& a,
     throw ex;
 }
 
+void
+InitialI::opDerivedException(const Optional<Int>& a,
+                             const Optional<string>& b,
+                             const Optional<OneOptionalPtr>& o,
+                             const Ice::Current&)
+{
+    DerivedException ex;
+    ex.a = a;
+    ex.b = b;
+    ex.o = o;
+    ex.ss = b;
+    ex.o2 = o;
+    throw ex;
+}
+
+void
+InitialI::opRequiredException(const Optional<Int>& a,
+                              const Optional<string>& b,
+                              const Optional<OneOptionalPtr>& o,
+                              const Ice::Current&)
+{
+    RequiredException ex;
+    ex.a = a;
+    ex.b = b;
+    ex.o = o;
+    if(b)
+    {
+        ex.ss = b.get();
+    }
+    if(o)
+    {
+        ex.o2 = o.get();
+    }
+    throw ex;
+}
+
 Optional<Ice::Byte>
 InitialI::opByte(const Optional<Ice::Byte>& p1, Optional<Ice::Byte>& p3, const Current&)
 {
@@ -51,6 +87,27 @@ InitialI::opByte(const Optional<Ice::Byte>& p1, Optional<Ice::Byte>& p3, const C
     return p1;
 }
 
+Optional<bool>
+InitialI::opBool(const Optional<bool>& p1, Optional<bool>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<Short>
+InitialI::opShort(const Optional<Short>& p1, Optional<Short>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<Int>
+InitialI::opInt(const Optional<Int>& p1, Optional<Int>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
 Optional<Long>
 InitialI::opLong(const Optional<Long>& p1, Optional<Long>& p3, const Current&)
 {
@@ -58,6 +115,20 @@ InitialI::opLong(const Optional<Long>& p1, Optional<Long>& p3, const Current&)
     return p1;
 }
 
+Optional<Float>
+InitialI::opFloat(const Optional<Float>& p1, Optional<Float>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<Double>
+InitialI::opDouble(const Optional<Double>& p1, Optional<Double>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
 Optional<string>
 InitialI::opString(const Optional<string>& p1, Optional<string>& p3, const Current&)
 {
@@ -65,6 +136,34 @@ InitialI::opString(const Optional<string>& p1, Optional<string>& p3, const Curre
     return p1;
 }
 
+Optional<MyEnum>
+InitialI::opMyEnum(const Optional<MyEnum>& p1, Optional<MyEnum>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<SmallStruct>
+InitialI::opSmallStruct(const Optional<SmallStruct>& p1, Optional<SmallStruct>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<FixedStruct>
+InitialI::opFixedStruct(const Optional<FixedStruct>& p1, Optional<FixedStruct>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
+Optional<VarStruct>
+InitialI::opVarStruct(const Optional<VarStruct>& p1, Optional<VarStruct>& p3, const Current&)
+{
+    p3 = p1;
+    return p1;
+}
+
 Optional<OneOptionalPtr>
 InitialI::opOneOptional(const Optional<OneOptionalPtr>& p1, Optional<OneOptionalPtr>& p3, const Current&)
 {
@@ -79,8 +178,8 @@ InitialI::opOneOptionalProxy(const Optional<OneOptionalPrx>& p1, Optional<OneOpt
     return p1;
 }
 
-Optional<Ice::ByteSeq>
-InitialI::opByteSeq(const Optional<pair<const Ice::Byte*, const Ice::Byte*> >& p1, Optional<Ice::ByteSeq>& p3,
+Optional<Test::ByteSeq>
+InitialI::opByteSeq(const Optional<pair<const Ice::Byte*, const Ice::Byte*> >& p1, Optional<Test::ByteSeq>& p3,
                     const Current&)
 {
     if(p1)
@@ -90,8 +189,19 @@ InitialI::opByteSeq(const Optional<pair<const Ice::Byte*, const Ice::Byte*> >& p
     return p3;
 }
 
-Optional<Ice::ShortSeq>
-InitialI::opShortSeq(const Optional<pair<const Short*, const Short*> >& p1, Optional<Ice::ShortSeq>& p3, const Current&)
+Optional<Test::BoolSeq>
+InitialI::opBoolSeq(const Optional<pair<const bool*, const bool*> >& p1, Optional<Test::BoolSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = Ice::BoolSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<Test::ShortSeq>
+InitialI::opShortSeq(const Optional<pair<const Short*, const Short*> >& p1, Optional<Test::ShortSeq>& p3,
+                     const Current&)
 {
     if(p1)
     {
@@ -100,20 +210,51 @@ InitialI::opShortSeq(const Optional<pair<const Short*, const Short*> >& p1, Opti
     return p3;
 }
 
-Optional<Ice::BoolSeq>
-InitialI::opBoolSeq(const Optional<pair<const bool*, const bool*> >& p1, Optional<Ice::BoolSeq>& p3, const Current&)
+Optional<Test::IntSeq>
+InitialI::opIntSeq(const Optional<pair<const Int*, const Int*> >& p1, Optional<Test::IntSeq>& p3, const Current&)
 {
     if(p1)
     {
-        p3 = Ice::BoolSeq(p1->first, p1->second);
+        p3 = Test::IntSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<Test::LongSeq>
+InitialI::opLongSeq(const Optional<pair<const Long*, const Long*> >& p1, Optional<Test::LongSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = Test::LongSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<Test::FloatSeq>
+InitialI::opFloatSeq(const Optional<pair<const Float*, const Float*> >& p1, Optional<Test::FloatSeq>& p3,
+                     const Current&)
+{
+    if(p1)
+    {
+        p3 = Test::FloatSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<Test::DoubleSeq>
+InitialI::opDoubleSeq(const Optional<pair<const Double*, const Double*> >& p1, Optional<Test::DoubleSeq>& p3,
+                      const Current&)
+{
+    if(p1)
+    {
+        p3 = Test::DoubleSeq(p1->first, p1->second);
     }
     return p3;
 }
 
 Optional<Ice::StringSeq>
 InitialI::opStringSeq(const Optional<pair<Ice::StringSeq::const_iterator, Ice::StringSeq::const_iterator> >& p1,
-                      Optional<Ice::StringSeq>& p3,
-                      const Current&)
+                      Optional<Ice::StringSeq>& p3, const Current&)
 {
     if(p1)
     {
@@ -122,10 +263,31 @@ InitialI::opStringSeq(const Optional<pair<Ice::StringSeq::const_iterator, Ice::S
     return p3;
 }
 
+Optional<SmallStructSeq>
+InitialI::opSmallStructSeq(const Optional<pair<const SmallStruct*, const SmallStruct*> >& p1,
+                           Optional<SmallStructSeq>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = SmallStructSeq(p1->first, p1->second);
+    }
+    return p3;
+}
+
+Optional<SmallStructList>
+InitialI::opSmallStructList(const Optional<pair<const SmallStruct*, const SmallStruct*> >& p1,
+                            Optional<SmallStructList>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = SmallStructList(p1->first, p1->second);
+    }
+    return p3;
+}
+
 Optional<FixedStructSeq>
 InitialI::opFixedStructSeq(const Optional<pair<const FixedStruct*, const FixedStruct*> >& p1,
-                           Optional<FixedStructSeq>& p3,
-                           const Current&)
+                           Optional<FixedStructSeq>& p3, const Current&)
 {
     if(p1)
     {
@@ -134,10 +296,20 @@ InitialI::opFixedStructSeq(const Optional<pair<const FixedStruct*, const FixedSt
     return p3;
 }
 
+Optional<FixedStructList>
+InitialI::opFixedStructList(const Optional<pair<const FixedStruct*, const FixedStruct*> >& p1,
+                            Optional<FixedStructList>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = FixedStructList(p1->first, p1->second);
+    }
+    return p3;
+}
+
 Optional<VarStructSeq>
 InitialI::opVarStructSeq(const Optional<pair<VarStructSeq::const_iterator, VarStructSeq::const_iterator> >& p1,
-                         Optional<VarStructSeq>& p3,
-                         const Current&)
+                         Optional<VarStructSeq>& p3, const Current&)
 {
     if(p1)
     {
@@ -146,6 +318,26 @@ InitialI::opVarStructSeq(const Optional<pair<VarStructSeq::const_iterator, VarSt
     return p3;
 }
 
+Optional<IntIntDict>
+InitialI::opIntIntDict(const Optional<IntIntDict>& p1, Optional<IntIntDict>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = p1;
+    }
+    return p3;
+}
+
+Optional<StringIntDict>
+InitialI::opStringIntDict(const Optional<StringIntDict>& p1, Optional<StringIntDict>& p3, const Current&)
+{
+    if(p1)
+    {
+        p3 = p1;
+    }
+    return p3;
+}
+
 void
 InitialI::opClassAndUnknownOptional(const APtr& a, const Ice::Current&)
 {
diff --git a/cpp/test/Ice/optional/TestI.h b/cpp/test/Ice/optional/TestI.h
index e6d5d07c60b..2a0e769bc61 100644
--- a/cpp/test/Ice/optional/TestI.h
+++ b/cpp/test/Ice/optional/TestI.h
@@ -22,60 +22,147 @@ public:
     virtual void shutdown(const Ice::Current&);
     virtual Ice::ObjectPtr pingPong(const Ice::ObjectPtr&, const Ice::Current&);
 
-    virtual void opOptionalException(const IceUtil::Optional< ::Ice::Int>&, 
+    virtual void opOptionalException(const IceUtil::Optional< ::Ice::Int>&,
                                      const IceUtil::Optional< ::std::string>&,
                                      const IceUtil::Optional<Test::OneOptionalPtr>&,
                                      const Ice::Current&);
 
-    virtual IceUtil::Optional< ::Ice::Byte> opByte(const IceUtil::Optional< ::Ice::Byte>&, 
-                                                   IceUtil::Optional< ::Ice::Byte>&, 
+    virtual void opDerivedException(const IceUtil::Optional< ::Ice::Int>&,
+                                    const IceUtil::Optional< ::std::string>&,
+                                    const IceUtil::Optional<Test::OneOptionalPtr>&,
+                                    const Ice::Current&);
+
+    virtual void opRequiredException(const IceUtil::Optional< ::Ice::Int>&,
+                                     const IceUtil::Optional< ::std::string>&,
+                                     const IceUtil::Optional<Test::OneOptionalPtr>&,
+                                     const Ice::Current&);
+
+    virtual IceUtil::Optional< ::Ice::Byte> opByte(const IceUtil::Optional< ::Ice::Byte>&,
+                                                   IceUtil::Optional< ::Ice::Byte>&,
                                                    const ::Ice::Current&);
-    
-    virtual IceUtil::Optional< ::Ice::Long> opLong(const IceUtil::Optional< ::Ice::Long>&, 
-                                                   IceUtil::Optional< ::Ice::Long>&, 
+
+    virtual IceUtil::Optional< bool> opBool(const IceUtil::Optional< bool>&, IceUtil::Optional< bool>&,
+                                            const ::Ice::Current&);
+
+    virtual IceUtil::Optional< ::Ice::Short> opShort(const IceUtil::Optional< ::Ice::Short>&,
+                                                     IceUtil::Optional< ::Ice::Short>&,
+                                                     const ::Ice::Current&);
+
+    virtual IceUtil::Optional< ::Ice::Int> opInt(const IceUtil::Optional< ::Ice::Int>&,
+                                                 IceUtil::Optional< ::Ice::Int>&,
+                                                 const ::Ice::Current&);
+
+    virtual IceUtil::Optional< ::Ice::Long> opLong(const IceUtil::Optional< ::Ice::Long>&,
+                                                   IceUtil::Optional< ::Ice::Long>&,
                                                    const ::Ice::Current&);
 
-    virtual IceUtil::Optional< ::std::string> opString(const IceUtil::Optional< ::std::string>&, 
-                                                       IceUtil::Optional< ::std::string>&, 
+    virtual IceUtil::Optional< ::Ice::Float> opFloat(const IceUtil::Optional< ::Ice::Float>&,
+                                                     IceUtil::Optional< ::Ice::Float>&,
+                                                     const ::Ice::Current&);
+
+    virtual IceUtil::Optional< ::Ice::Double> opDouble(const IceUtil::Optional< ::Ice::Double>&,
+                                                       IceUtil::Optional< ::Ice::Double>&,
                                                        const ::Ice::Current&);
 
-    virtual IceUtil::Optional<Test::OneOptionalPtr> opOneOptional(const IceUtil::Optional< Test::OneOptionalPtr>&, 
-                                                                  IceUtil::Optional< Test::OneOptionalPtr>&, 
+    virtual IceUtil::Optional< ::std::string> opString(const IceUtil::Optional< ::std::string>&,
+                                                       IceUtil::Optional< ::std::string>&,
+                                                       const ::Ice::Current&);
+
+    virtual IceUtil::Optional< Test::MyEnum> opMyEnum(const IceUtil::Optional<Test::MyEnum>&,
+                                                      IceUtil::Optional<Test::MyEnum>&,
+                                                      const ::Ice::Current&);
+
+    virtual IceUtil::Optional<Test::SmallStruct> opSmallStruct(const IceUtil::Optional<Test::SmallStruct>&,
+                                                               IceUtil::Optional<Test::SmallStruct>&,
+                                                               const ::Ice::Current&);
+
+    virtual IceUtil::Optional<Test::FixedStruct> opFixedStruct(const IceUtil::Optional<Test::FixedStruct>&,
+                                                               IceUtil::Optional<Test::FixedStruct>&,
+                                                               const ::Ice::Current&);
+
+    virtual IceUtil::Optional<Test::VarStruct> opVarStruct(const IceUtil::Optional<Test::VarStruct>&,
+                                                           IceUtil::Optional<Test::VarStruct>&,
+                                                           const ::Ice::Current&);
+
+    virtual IceUtil::Optional<Test::OneOptionalPtr> opOneOptional(const IceUtil::Optional< Test::OneOptionalPtr>&,
+                                                                  IceUtil::Optional< Test::OneOptionalPtr>&,
                                                                   const ::Ice::Current&);
-    
-    virtual IceUtil::Optional<Test::OneOptionalPrx> opOneOptionalProxy(const IceUtil::Optional< Test::OneOptionalPrx>&, 
-                                                                       IceUtil::Optional< Test::OneOptionalPrx>&, 
+
+    virtual IceUtil::Optional<Test::OneOptionalPrx> opOneOptionalProxy(const IceUtil::Optional< Test::OneOptionalPrx>&,
+                                                                       IceUtil::Optional< Test::OneOptionalPrx>&,
                                                                        const ::Ice::Current&);
-    
+
     virtual IceUtil::Optional< ::Test::ByteSeq> opByteSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> >&, 
-        IceUtil::Optional< ::Test::ByteSeq>&, 
+        const IceUtil::Optional< ::std::pair<const ::Ice::Byte*, const ::Ice::Byte*> >&,
+        IceUtil::Optional< ::Test::ByteSeq>&,
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::BoolSeq> opBoolSeq(
+        const IceUtil::Optional< ::std::pair<const bool*, const bool*> >&,
+        IceUtil::Optional< ::Test::BoolSeq>&,
         const ::Ice::Current& = ::Ice::Current());
 
     virtual IceUtil::Optional< ::Test::ShortSeq> opShortSeq(
-        const IceUtil::Optional< ::std::pair<const ::Ice::Short*, const ::Ice::Short*> >&, 
-        IceUtil::Optional< ::Test::ShortSeq>&, 
+        const IceUtil::Optional< ::std::pair<const ::Ice::Short*, const ::Ice::Short*> >&,
+        IceUtil::Optional< ::Test::ShortSeq>&,
         const ::Ice::Current& = ::Ice::Current());
 
-    virtual IceUtil::Optional< ::Test::BoolSeq> opBoolSeq(
-        const IceUtil::Optional< ::std::pair<const bool*, const bool*> >&, 
-        IceUtil::Optional< ::Test::BoolSeq>&, 
+    virtual IceUtil::Optional< ::Test::IntSeq> opIntSeq(
+        const IceUtil::Optional< ::std::pair<const ::Ice::Int*, const ::Ice::Int*> >&,
+        IceUtil::Optional< ::Test::IntSeq>&,
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::LongSeq> opLongSeq(
+        const IceUtil::Optional< ::std::pair<const ::Ice::Long*, const ::Ice::Long*> >&,
+        IceUtil::Optional< ::Test::LongSeq>&,
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::FloatSeq> opFloatSeq(
+        const IceUtil::Optional< ::std::pair<const ::Ice::Float*, const ::Ice::Float*> >&,
+        IceUtil::Optional< ::Test::FloatSeq>&,
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::DoubleSeq> opDoubleSeq(
+        const IceUtil::Optional< ::std::pair<const ::Ice::Double*, const ::Ice::Double*> >&,
+        IceUtil::Optional< ::Test::DoubleSeq>&,
         const ::Ice::Current& = ::Ice::Current());
 
     virtual IceUtil::Optional< ::Test::StringSeq> opStringSeq(
-        const IceUtil::Optional< ::std::pair< ::Test::StringSeq::const_iterator, 
+        const IceUtil::Optional< ::std::pair< ::Test::StringSeq::const_iterator,
                                               ::Test::StringSeq::const_iterator> >&,
-        IceUtil::Optional< ::Test::StringSeq>&, 
+        IceUtil::Optional< ::Test::StringSeq>&,
         const ::Ice::Current& = ::Ice::Current());
 
+    virtual IceUtil::Optional< ::Test::SmallStructSeq> opSmallStructSeq(
+        const IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >&,
+        IceUtil::Optional< ::Test::SmallStructSeq>&, const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::SmallStructList> opSmallStructList(
+        const IceUtil::Optional< ::std::pair<const ::Test::SmallStruct*, const ::Test::SmallStruct*> >&,
+        IceUtil::Optional< ::Test::SmallStructList>&, const ::Ice::Current& = ::Ice::Current());
+
     virtual IceUtil::Optional< ::Test::FixedStructSeq> opFixedStructSeq(
         const IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >&,
         IceUtil::Optional< ::Test::FixedStructSeq>&, const ::Ice::Current& = ::Ice::Current());
-    
+
+    virtual IceUtil::Optional< ::Test::FixedStructList> opFixedStructList(
+        const IceUtil::Optional< ::std::pair<const ::Test::FixedStruct*, const ::Test::FixedStruct*> >&,
+        IceUtil::Optional< ::Test::FixedStructList>&, const ::Ice::Current& = ::Ice::Current());
+
     virtual IceUtil::Optional< ::Test::VarStructSeq> opVarStructSeq(
-        const IceUtil::Optional< ::std::pair< ::Test::VarStructSeq::const_iterator, 
+        const IceUtil::Optional< ::std::pair< ::Test::VarStructSeq::const_iterator,
                                               ::Test::VarStructSeq::const_iterator> >&,
-        IceUtil::Optional< ::Test::VarStructSeq>&, 
+        IceUtil::Optional< ::Test::VarStructSeq>&,
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::IntIntDict> opIntIntDict(
+        const IceUtil::Optional< ::Test::IntIntDict>&,
+        IceUtil::Optional< ::Test::IntIntDict>&,
+        const ::Ice::Current& = ::Ice::Current());
+
+    virtual IceUtil::Optional< ::Test::StringIntDict> opStringIntDict(
+        const IceUtil::Optional< ::Test::StringIntDict>&,
+        IceUtil::Optional< ::Test::StringIntDict>&,
         const ::Ice::Current& = ::Ice::Current());
 
     virtual void opClassAndUnknownOptional(const Test::APtr&, const Ice::Current&);