ICE-6485 enums tests fails with --cross=objective-c

14 files changed, 372 insertions, 1 deletions

diff --git a/cpp/test/Ice/enums/AllTests.cpp b/cpp/test/Ice/enums/AllTests.cpp
index a300ee492d7..b8addd69923 100644
--- a/cpp/test/Ice/enums/AllTests.cpp
+++ b/cpp/test/Ice/enums/AllTests.cpp
@@ -126,6 +126,66 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
     cout << "ok" << endl;
 
+    cout << "testing enum sequences operations... " << flush;
+
+    {
+        ByteEnum values[] = { benum1, benum2, benum3, benum4, benum5, benum6, benum7, benum8, benum9, benum10, benum11};
+        ByteEnumSeq b1(&values[0], &values[0] + sizeof(values) / sizeof(ByteEnum));
+
+        ByteEnumSeq b2;
+        ByteEnumSeq b3 = proxy->opByteSeq(b1, b2);
+
+        for(int i = 0; i < b1.size(); ++i)
+        {
+            test(b1[i] == b2[i]);
+            test(b1[i] == b3[i]);
+        }
+    }
+
+    {
+        ShortEnum values[] = { senum1, senum2, senum3, senum4, senum5, senum6, senum7, senum8, senum9, senum10, senum11};
+        ShortEnumSeq s1(&values[0], &values[0] + sizeof(values) / sizeof(ShortEnum));
+
+        ShortEnumSeq s2;
+        ShortEnumSeq s3 = proxy->opShortSeq(s1, s2);
+
+        for(int i = 0; i < s1.size(); ++i)
+        {
+            test(s1[i] == s2[i]);
+            test(s1[i] == s3[i]);
+        }
+    }
+
+    {
+        IntEnum values[] = { ienum1, ienum2, ienum3, ienum4, ienum5, ienum6, ienum7, ienum8, ienum9, ienum10, ienum11};
+        IntEnumSeq i1(&values[0], &values[0] + sizeof(values) / sizeof(IntEnum));
+
+        IntEnumSeq i2;
+        IntEnumSeq i3 = proxy->opIntSeq(i1, i2);
+
+        for(int i = 0; i < i1.size(); ++i)
+        {
+            test(i1[i] == i2[i]);
+            test(i1[i] == i3[i]);
+        }
+    }
+
+    {
+        SimpleEnum values[] = { red, green, blue };
+        SimpleEnumSeq s1(&values[0], &values[0] + sizeof(values) / sizeof(SimpleEnum));
+
+        SimpleEnumSeq s2;
+        SimpleEnumSeq s3 = proxy->opSimpleSeq(s1, s2);
+
+        for(int i = 0; i < s1.size(); ++i)
+        {
+            test(s1[i] == s2[i]);
+            test(s1[i] == s3[i]);
+        }
+    }
+
+    cout << "ok" << endl;
+
     cout << "testing enum exceptions... " << flush;
 
     try
diff --git a/cpp/test/Ice/enums/Test.ice b/cpp/test/Ice/enums/Test.ice
index 1cfe8c3eda8..8f613f4e80c 100644
--- a/cpp/test/Ice/enums/Test.ice
+++ b/cpp/test/Ice/enums/Test.ice
@@ -36,6 +36,7 @@ enum ByteEnum
     benum10,
     benum11 = ByteConst2
 };
+sequence<ByteEnum> ByteEnumSeq;
 
 enum ShortEnum
 {
@@ -51,6 +52,7 @@ enum ShortEnum
     senum10,
     senum11 = ShortConst2
 };
+sequence<ShortEnum> ShortEnumSeq;
 
 enum IntEnum
 {
@@ -67,6 +69,7 @@ enum IntEnum
     ienum11 = IntConst2,
     ienum12 = LongConst2
 };
+sequence<IntEnum> IntEnumSeq;
 
 enum SimpleEnum
 {
@@ -74,6 +77,7 @@ enum SimpleEnum
     green,
     blue
 };
+sequence<SimpleEnum> SimpleEnumSeq;
 
 interface TestIntf
 {
@@ -82,6 +86,11 @@ interface TestIntf
     IntEnum opInt(IntEnum i1, out IntEnum i2);
     SimpleEnum opSimple(SimpleEnum s1, out SimpleEnum s2);
 
+    ByteEnumSeq opByteSeq(ByteEnumSeq b1, out ByteEnumSeq b2);
+    ShortEnumSeq opShortSeq(ShortEnumSeq s1, out ShortEnumSeq s2);
+    IntEnumSeq opIntSeq(IntEnumSeq i1, out IntEnumSeq i2);
+    SimpleEnumSeq opSimpleSeq(SimpleEnumSeq s1, out SimpleEnumSeq s2);
+
     void shutdown();
 };
 
diff --git a/cpp/test/Ice/enums/TestI.cpp b/cpp/test/Ice/enums/TestI.cpp
index 80f5565cb9e..f33fb635982 100644
--- a/cpp/test/Ice/enums/TestI.cpp
+++ b/cpp/test/Ice/enums/TestI.cpp
@@ -38,6 +38,34 @@ TestIntfI::opSimple(Test::SimpleEnum s1, Test::SimpleEnum& s2, const Ice::Curren
     return s1;
 }
 
+Test::ByteEnumSeq
+TestIntfI::opByteSeq(const Test::ByteEnumSeq& bs1, Test::ByteEnumSeq& bs2, const Ice::Current&)
+{
+    bs2 = bs1;
+    return bs1;
+}
+
+Test::ShortEnumSeq
+TestIntfI::opShortSeq(const Test::ShortEnumSeq& ss1, Test::ShortEnumSeq& ss2, const ::Ice::Current&)
+{
+    ss2 = ss1;
+    return ss1;
+}
+
+Test::IntEnumSeq
+TestIntfI::opIntSeq(const Test::IntEnumSeq& is1, Test::IntEnumSeq& is2, const ::Ice::Current&)
+{
+    is2 = is1;
+    return is1;
+}
+
+Test::SimpleEnumSeq
+TestIntfI::opSimpleSeq(const Test::SimpleEnumSeq& ss1, Test::SimpleEnumSeq& ss2, const ::Ice::Current&)
+{
+    ss2 = ss1;
+    return ss1;
+}
+
 void
 TestIntfI::shutdown(const Ice::Current& current)
 {
diff --git a/cpp/test/Ice/enums/TestI.h b/cpp/test/Ice/enums/TestI.h
index e7c8ef1cc83..7fd5af4ec22 100644
--- a/cpp/test/Ice/enums/TestI.h
+++ b/cpp/test/Ice/enums/TestI.h
@@ -24,6 +24,14 @@ public:
 
     virtual Test::SimpleEnum opSimple(Test::SimpleEnum, Test::SimpleEnum&, const Ice::Current&);
 
+    virtual Test::ByteEnumSeq opByteSeq(const Test::ByteEnumSeq&, Test::ByteEnumSeq&, const Ice::Current&);
+
+    virtual Test::ShortEnumSeq opShortSeq(const Test::ShortEnumSeq&, Test::ShortEnumSeq&, const ::Ice::Current&);
+
+    virtual Test::IntEnumSeq opIntSeq(const Test::IntEnumSeq&, Test::IntEnumSeq&, const ::Ice::Current&);
+
+    virtual Test::SimpleEnumSeq opSimpleSeq(const Test::SimpleEnumSeq&, Test::SimpleEnumSeq&, const ::Ice::Current&);
+
     virtual void shutdown(const Ice::Current&);
 };
 
diff --git a/csharp/test/Ice/enums/AllTests.cs b/csharp/test/Ice/enums/AllTests.cs
index 6834a400e78..bd463398d3e 100644
--- a/csharp/test/Ice/enums/AllTests.cs
+++ b/csharp/test/Ice/enums/AllTests.cs
@@ -139,6 +139,73 @@ public class AllTests : TestCommon.TestApp
 
         Console.Out.WriteLine("ok");
 
+        Console.Out.Write("testing enum sequences operations... ");
+        Console.Out.Flush();
+
+        {
+            ByteEnum[] b1 = new ByteEnum[11]
+                    { ByteEnum.benum1, ByteEnum.benum2, ByteEnum.benum3, ByteEnum.benum4, ByteEnum.benum5,
+                      ByteEnum.benum6, ByteEnum.benum7, ByteEnum.benum8, ByteEnum.benum9, ByteEnum.benum10,
+                      ByteEnum.benum11};
+
+            ByteEnum[] b2;
+            ByteEnum[] b3 = proxy.opByteSeq(b1, out b2);
+
+            for(int i = 0; i < b1.Length; ++i)
+            {
+                test(b1[i] == b2[i]);
+                test(b1[i] == b3[i]);
+            }
+        }
+
+        {
+            ShortEnum[] s1 = new ShortEnum[11]
+                    { ShortEnum.senum1, ShortEnum.senum2, ShortEnum.senum3, ShortEnum.senum4, ShortEnum.senum5,
+                      ShortEnum.senum6, ShortEnum.senum7, ShortEnum.senum8, ShortEnum.senum9, ShortEnum.senum10,
+                      ShortEnum.senum11};
+
+            ShortEnum[] s2;
+            ShortEnum[] s3 = proxy.opShortSeq(s1, out s2);
+
+            for(int i = 0; i < s1.Length; ++i)
+            {
+                test(s1[i] == s2[i]);
+                test(s1[i] == s3[i]);
+            }
+        }
+
+        {
+            IntEnum[] i1 = new IntEnum[11]
+                    { IntEnum.ienum1, IntEnum.ienum2, IntEnum.ienum3, IntEnum.ienum4, IntEnum.ienum5,
+                      IntEnum.ienum6, IntEnum.ienum7, IntEnum.ienum8, IntEnum.ienum9, IntEnum.ienum10,
+                      IntEnum.ienum11};
+
+            IntEnum[] i2;
+            IntEnum[] i3 = proxy.opIntSeq(i1, out i2);
+
+            for(int i = 0; i < i1.Length; ++i)
+            {
+                test(i1[i] == i2[i]);
+                test(i1[i] == i3[i]);
+            }
+        }
+
+        {
+            SimpleEnum[] s1 = new SimpleEnum[3]
+                    { SimpleEnum.red, SimpleEnum.green, SimpleEnum.blue };
+
+            SimpleEnum[] s2;
+            SimpleEnum[] s3 = proxy.opSimpleSeq(s1, out s2);
+
+            for(int i = 0; i < s1.Length; ++i)
+            {
+                test(s1[i] == s2[i]);
+                test(s1[i] == s3[i]);
+            }
+        }
+
+        Console.Out.WriteLine("ok");
+
         Console.Out.Write("testing enum exceptions... ");
         Console.Out.Flush();
 
diff --git a/csharp/test/Ice/enums/Test.ice b/csharp/test/Ice/enums/Test.ice
index 1cfe8c3eda8..8f613f4e80c 100644
--- a/csharp/test/Ice/enums/Test.ice
+++ b/csharp/test/Ice/enums/Test.ice
@@ -36,6 +36,7 @@ enum ByteEnum
     benum10,
     benum11 = ByteConst2
 };
+sequence<ByteEnum> ByteEnumSeq;
 
 enum ShortEnum
 {
@@ -51,6 +52,7 @@ enum ShortEnum
     senum10,
     senum11 = ShortConst2
 };
+sequence<ShortEnum> ShortEnumSeq;
 
 enum IntEnum
 {
@@ -67,6 +69,7 @@ enum IntEnum
     ienum11 = IntConst2,
     ienum12 = LongConst2
 };
+sequence<IntEnum> IntEnumSeq;
 
 enum SimpleEnum
 {
@@ -74,6 +77,7 @@ enum SimpleEnum
     green,
     blue
 };
+sequence<SimpleEnum> SimpleEnumSeq;
 
 interface TestIntf
 {
@@ -82,6 +86,11 @@ interface TestIntf
     IntEnum opInt(IntEnum i1, out IntEnum i2);
     SimpleEnum opSimple(SimpleEnum s1, out SimpleEnum s2);
 
+    ByteEnumSeq opByteSeq(ByteEnumSeq b1, out ByteEnumSeq b2);
+    ShortEnumSeq opShortSeq(ShortEnumSeq s1, out ShortEnumSeq s2);
+    IntEnumSeq opIntSeq(IntEnumSeq i1, out IntEnumSeq i2);
+    SimpleEnumSeq opSimpleSeq(SimpleEnumSeq s1, out SimpleEnumSeq s2);
+
     void shutdown();
 };
 
diff --git a/csharp/test/Ice/enums/TestI.cs b/csharp/test/Ice/enums/TestI.cs
index c016847f316..140d75620ce 100644
--- a/csharp/test/Ice/enums/TestI.cs
+++ b/csharp/test/Ice/enums/TestI.cs
@@ -39,6 +39,30 @@ public class TestI : TestIntfDisp_
         return s1;
     }
 
+    public override Test.ByteEnum[] opByteSeq(Test.ByteEnum[] b1, out Test.ByteEnum[] b2, Ice.Current current)
+    {
+        b2 = b1;
+        return b1;
+    }
+
+    public override Test.ShortEnum[] opShortSeq(Test.ShortEnum[] s1, out Test.ShortEnum[] s2, Ice.Current current)
+    {
+        s2 = s1;
+        return s1;
+    }
+
+    public override Test.IntEnum[] opIntSeq(Test.IntEnum[] i1, out Test.IntEnum[] i2, Ice.Current current)
+    {
+        i2 = i1;
+        return i1;
+    }
+
+    public override Test.SimpleEnum[] opSimpleSeq(Test.SimpleEnum[] s1, out Test.SimpleEnum[] s2, Ice.Current current)
+    {
+        s2 = s1;
+        return s1;
+    }
+
     public override void shutdown(Ice.Current current)
     {
         current.adapter.getCommunicator().shutdown();
diff --git a/java/test/src/main/java/test/Ice/enums/AllTests.java b/java/test/src/main/java/test/Ice/enums/AllTests.java
index 4f7ac04054c..3ece2a3f784 100644
--- a/java/test/src/main/java/test/Ice/enums/AllTests.java
+++ b/java/test/src/main/java/test/Ice/enums/AllTests.java
@@ -179,6 +179,69 @@ public class AllTests
 
         out.println("ok");
 
+        out.print("testing enum sequences operations... ");
+        out.flush();
+
+        {
+            ByteEnum b1[] = { ByteEnum.benum1, ByteEnum.benum2, ByteEnum.benum3, ByteEnum.benum4, ByteEnum.benum5,
+                              ByteEnum.benum6, ByteEnum.benum7, ByteEnum.benum8, ByteEnum.benum9, ByteEnum.benum10,
+                              ByteEnum.benum11};
+
+            ByteEnumSeqHolder b2 = new ByteEnumSeqHolder();
+            ByteEnum b3[] = proxy.opByteSeq(b1, b2);
+
+            for(int i = 0; i < b1.length; ++i)
+            {
+                test(b1[i] == b2.value[i]);
+                test(b1[i] == b3[i]);
+            }
+        }
+
+        {
+            ShortEnum s1[] = { ShortEnum.senum1, ShortEnum.senum2, ShortEnum.senum3, ShortEnum.senum4, ShortEnum.senum5,
+                               ShortEnum.senum6, ShortEnum.senum7, ShortEnum.senum8, ShortEnum.senum9, ShortEnum.senum10,
+                               ShortEnum.senum11};
+
+            ShortEnumSeqHolder s2 = new ShortEnumSeqHolder();
+            ShortEnum s3[] = proxy.opShortSeq(s1, s2);
+
+            for(int i = 0; i < s1.length; ++i)
+            {
+                test(s1[i] == s2.value[i]);
+                test(s1[i] == s3[i]);
+            }
+        }
+
+        {
+            IntEnum i1[] = { IntEnum.ienum1, IntEnum.ienum2, IntEnum.ienum3, IntEnum.ienum4, IntEnum.ienum5,
+                             IntEnum.ienum6, IntEnum.ienum7, IntEnum.ienum8, IntEnum.ienum9, IntEnum.ienum10,
+                             IntEnum.ienum11};
+
+            IntEnumSeqHolder i2 = new IntEnumSeqHolder();
+            IntEnum i3[] = proxy.opIntSeq(i1, i2);
+
+            for(int i = 0; i < i1.length; ++i)
+            {
+                test(i1[i] == i2.value[i]);
+                test(i1[i] == i3[i]);
+            }
+        }
+
+        {
+            SimpleEnum s1[] = { SimpleEnum.red, SimpleEnum.green, SimpleEnum.blue };
+
+            SimpleEnumSeqHolder s2 = new SimpleEnumSeqHolder();
+            SimpleEnum s3[] = proxy.opSimpleSeq(s1, s2);
+
+            for(int i = 0; i < s1.length; ++i)
+            {
+                test(s1[i] == s2.value[i]);
+                test(s1[i] == s3[i]);
+            }
+        }
+
+        out.println("ok");
+
         out.print("testing enum exceptions... ");
         out.flush();
 
diff --git a/java/test/src/main/java/test/Ice/enums/Test.ice b/java/test/src/main/java/test/Ice/enums/Test.ice
index 39fed6194c4..aa3d20845cb 100644
--- a/java/test/src/main/java/test/Ice/enums/Test.ice
+++ b/java/test/src/main/java/test/Ice/enums/Test.ice
@@ -37,6 +37,7 @@ enum ByteEnum
     benum10,
     benum11 = ByteConst2
 };
+sequence<ByteEnum> ByteEnumSeq;
 
 enum ShortEnum
 {
@@ -52,6 +53,7 @@ enum ShortEnum
     senum10,
     senum11 = ShortConst2
 };
+sequence<ShortEnum> ShortEnumSeq;
 
 enum IntEnum
 {
@@ -68,6 +70,7 @@ enum IntEnum
     ienum11 = IntConst2,
     ienum12 = LongConst2
 };
+sequence<IntEnum> IntEnumSeq;
 
 enum SimpleEnum
 {
@@ -75,6 +78,7 @@ enum SimpleEnum
     green,
     blue
 };
+sequence<SimpleEnum> SimpleEnumSeq;
 
 interface TestIntf
 {
@@ -83,6 +87,11 @@ interface TestIntf
     IntEnum opInt(IntEnum i1, out IntEnum i2);
     SimpleEnum opSimple(SimpleEnum s1, out SimpleEnum s2);
 
+    ByteEnumSeq opByteSeq(ByteEnumSeq b1, out ByteEnumSeq b2);
+    ShortEnumSeq opShortSeq(ShortEnumSeq s1, out ShortEnumSeq s2);
+    IntEnumSeq opIntSeq(IntEnumSeq i1, out IntEnumSeq i2);
+    SimpleEnumSeq opSimpleSeq(SimpleEnumSeq s1, out SimpleEnumSeq s2);
+
     void shutdown();
 };
 
diff --git a/java/test/src/main/java/test/Ice/enums/TestIntfI.java b/java/test/src/main/java/test/Ice/enums/TestIntfI.java
index c3cd28f758d..7a5b0e1c303 100644
--- a/java/test/src/main/java/test/Ice/enums/TestIntfI.java
+++ b/java/test/src/main/java/test/Ice/enums/TestIntfI.java
@@ -46,6 +46,38 @@ public final class TestIntfI extends _TestIntfDisp
     }
 
     @Override
+    public ByteEnum[]
+    opByteSeq(ByteEnum[] b1, ByteEnumSeqHolder b2, Ice.Current current)
+    {
+        b2.value = b1;
+        return b1;
+    }
+
+    @Override
+    public ShortEnum[]
+    opShortSeq(ShortEnum[] s1, ShortEnumSeqHolder s2, Ice.Current current)
+    {
+        s2.value = s1;
+        return s1;
+    }
+
+    @Override
+    public IntEnum[]
+    opIntSeq(IntEnum[] i1, IntEnumSeqHolder i2, Ice.Current current)
+    {
+        i2.value = i1;
+        return i1;
+    }
+
+    @Override
+    public SimpleEnum[]
+    opSimpleSeq(SimpleEnum[] s1, SimpleEnumSeqHolder s2, Ice.Current current)
+    {
+        s2.value = s1;
+        return s1;
+    }
+
+    @Override
     public void
     shutdown(Ice.Current current)
     {
diff --git a/objective-c/test/Ice/enums/AllTests.m b/objective-c/test/Ice/enums/AllTests.m
index 4ce24b2b959..d2d97458d01 100644
--- a/objective-c/test/Ice/enums/AllTests.m
+++ b/objective-c/test/Ice/enums/AllTests.m
@@ -123,7 +123,6 @@ enumAllTests(id<ICECommunicator> communicator)
     }
 
     {
-
         TestEnumShortEnum values[] = {TestEnumsenum1, TestEnumsenum2, TestEnumsenum3, TestEnumsenum4, TestEnumsenum5,
                                      TestEnumsenum6, TestEnumsenum7, TestEnumsenum8, TestEnumsenum9, TestEnumsenum10,
                                      TestEnumsenum11};
diff --git a/python/test/Ice/enums/AllTests.py b/python/test/Ice/enums/AllTests.py
index a5dae46cff9..60694e9c60d 100644
--- a/python/test/Ice/enums/AllTests.py
+++ b/python/test/Ice/enums/AllTests.py
@@ -125,4 +125,46 @@ def allTests(communicator):
 
     print("ok")
 
+    sys.stdout.write("testing enum sequences operations... ")
+    sys.stdout.flush()
+
+    b1 = [ Test.ByteEnum.benum1, Test.ByteEnum.benum2, Test.ByteEnum.benum3, Test.ByteEnum.benum4, Test.ByteEnum.benum5,
+           Test.ByteEnum.benum6, Test.ByteEnum.benum7, Test.ByteEnum.benum8, Test.ByteEnum.benum9, Test.ByteEnum.benum10,
+           Test.ByteEnum.benum11 ]
+
+    (b2, b3) = proxy.opByteSeq(b1)
+
+    for i in range(len(b1)):
+        test(b1[i] == b2[i])
+        test(b1[i] == b3[i])
+
+    s1 = [ Test.ShortEnum.senum1, Test.ShortEnum.senum2, Test.ShortEnum.senum3, Test.ShortEnum.senum4,
+           Test.ShortEnum.senum5, Test.ShortEnum.senum6, Test.ShortEnum.senum7, Test.ShortEnum.senum8,
+           Test.ShortEnum.senum9, Test.ShortEnum.senum10, Test.ShortEnum.senum11 ]
+
+    (s2, s3) = proxy.opShortSeq(s1)
+
+    for i in range(len(s1)):
+        test(s1[i] == s2[i])
+        test(s1[i] == s3[i])
+
+    i1 = [ Test.IntEnum.ienum1, Test.IntEnum.ienum2, Test.IntEnum.ienum3, Test.IntEnum.ienum4,
+           Test.IntEnum.ienum5, Test.IntEnum.ienum6, Test.IntEnum.ienum7, Test.IntEnum.ienum8,
+           Test.IntEnum.ienum9, Test.IntEnum.ienum10, Test.IntEnum.ienum11 ]
+
+    (i2, i3) = proxy.opIntSeq(i1)
+
+    for i in range(len(i1)):
+        test(i1[i] == i2[i])
+        test(i1[i] == i3[i])
+
+    s1 = [ Test.SimpleEnum.red, Test.SimpleEnum.green, Test.SimpleEnum.blue ]
+
+    (s2, s3) = proxy.opSimpleSeq(s1)
+
+    for i in range(len(s1)):
+        test(s1[i] == s2[i])
+        test(s1[i] == s3[i])
+    print("ok")
+
     return proxy
diff --git a/python/test/Ice/enums/Server.py b/python/test/Ice/enums/Server.py
index f51922e12fc..cfaed170f22 100755
--- a/python/test/Ice/enums/Server.py
+++ b/python/test/Ice/enums/Server.py
@@ -31,6 +31,18 @@ class TestIntfI(Test.TestIntf):
     def opSimple(self, s1, current=None):
         return (s1, s1)
 
+    def opByteSeq(self, b1, current=None):
+        return (b1, b1)
+
+    def opShortSeq(self, s1, current=None):
+        return (s1, s1)
+
+    def opIntSeq(self, i1, current=None):
+        return (i1, i1)
+
+    def opSimpleSeq(self, s1, current=None):
+        return (s1, s1)
+
     def shutdown(self, current=None):
         current.adapter.getCommunicator().shutdown()
 
diff --git a/python/test/Ice/enums/Test.ice b/python/test/Ice/enums/Test.ice
index 1cfe8c3eda8..8f613f4e80c 100644
--- a/python/test/Ice/enums/Test.ice
+++ b/python/test/Ice/enums/Test.ice
@@ -36,6 +36,7 @@ enum ByteEnum
     benum10,
     benum11 = ByteConst2
 };
+sequence<ByteEnum> ByteEnumSeq;
 
 enum ShortEnum
 {
@@ -51,6 +52,7 @@ enum ShortEnum
     senum10,
     senum11 = ShortConst2
 };
+sequence<ShortEnum> ShortEnumSeq;
 
 enum IntEnum
 {
@@ -67,6 +69,7 @@ enum IntEnum
     ienum11 = IntConst2,
     ienum12 = LongConst2
 };
+sequence<IntEnum> IntEnumSeq;
 
 enum SimpleEnum
 {
@@ -74,6 +77,7 @@ enum SimpleEnum
     green,
     blue
 };
+sequence<SimpleEnum> SimpleEnumSeq;
 
 interface TestIntf
 {
@@ -82,6 +86,11 @@ interface TestIntf
     IntEnum opInt(IntEnum i1, out IntEnum i2);
     SimpleEnum opSimple(SimpleEnum s1, out SimpleEnum s2);
 
+    ByteEnumSeq opByteSeq(ByteEnumSeq b1, out ByteEnumSeq b2);
+    ShortEnumSeq opShortSeq(ShortEnumSeq s1, out ShortEnumSeq s2);
+    IntEnumSeq opIntSeq(IntEnumSeq i1, out IntEnumSeq i2);
+    SimpleEnumSeq opSimpleSeq(SimpleEnumSeq s1, out SimpleEnumSeq s2);
+
     void shutdown();
 };