Fixed slice2matlab generated code type for dictionary data members

Close #256

28 files changed, 401 insertions, 3 deletions

diff --git a/CHANGELOG-3.7.md b/CHANGELOG-3.7.md
index 7d7a004c3b9..0dd4889e276 100644
--- a/CHANGELOG-3.7.md
+++ b/CHANGELOG-3.7.md
@@ -67,6 +67,12 @@ These are the changes since Ice 3.7.1 included in this pre-release.
 - Slice to JavaScript compiler can now generate TypeScript declaration files
   for JavaScript generated code using `--typescript` command line option.
 
+## Matlab Changes
+
+- Fixed a bug that cause slice2matab generated code to throw type conversion
+  exception, this affects classes or struct containing an array mapped to an
+  structure array.
+
 # Changes in Ice 3.7.1
 
 These are the changes since Ice 3.7.0.
diff --git a/cpp/src/slice2matlab/Main.cpp b/cpp/src/slice2matlab/Main.cpp
index 051e37b76ac..c673feb482b 100644
--- a/cpp/src/slice2matlab/Main.cpp
+++ b/cpp/src/slice2matlab/Main.cpp
@@ -362,7 +362,11 @@ typeToString(const TypePtr& type)
     DictionaryPtr dict = DictionaryPtr::dynamicCast(type);
     if(dict)
     {
-        if(!StructPtr::dynamicCast(dict->keyType()))
+        if(StructPtr::dynamicCast(dict->keyType()))
+        {
+            return "struct";
+        }
+        else
         {
             return "containers.Map";
         }
@@ -3599,7 +3603,7 @@ CodeVisitor::visitDictionary(const DictionaryPtr& p)
 
         if(cls || convert)
         {
-            out << nl << "function r = convert(d, obj)";
+            out << nl << "function r = convert(d)";
             out.inc();
             if(st)
             {
diff --git a/cpp/test/Ice/objects/AllTests.cpp b/cpp/test/Ice/objects/AllTests.cpp
index a7ef9968ca8..7633f3732bb 100644
--- a/cpp/test/Ice/objects/AllTests.cpp
+++ b/cpp/test/Ice/objects/AllTests.cpp
@@ -536,5 +536,34 @@ allTests(Test::TestHelper* helper)
     {
     }
 
+    cout << "testing class containing complex dictionary... " << flush;
+    {
+        Test::MPtr m = ICE_MAKE_SHARED(Test::M);
+
+        Test::StructKey k1;
+        k1.i = 1;
+        k1.s = "1";
+        m->v[k1] = ICE_MAKE_SHARED(L, "one");
+
+        Test::StructKey k2;
+        k2.i = 2;
+        k2.s = "2";
+        m->v[k2] = ICE_MAKE_SHARED(L, "two");
+
+        Test::MPtr m1;
+        Test::MPtr m2 = initial->opM(m, m1);
+
+        test(m1->v.size() == 2);
+        test(m2->v.size() == 2);
+
+        test(m1->v[k1]->data == "one");
+        test(m2->v[k1]->data == "one");
+
+        test(m1->v[k2]->data == "two");
+        test(m2->v[k2]->data == "two");
+
+    }
+    cout << "ok" << endl;
+
     return initial;
 }
diff --git a/cpp/test/Ice/objects/Test.ice b/cpp/test/Ice/objects/Test.ice
index e3d8b9cca1e..e14044e7118 100644
--- a/cpp/test/Ice/objects/Test.ice
+++ b/cpp/test/Ice/objects/Test.ice
@@ -190,6 +190,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 interface Initial
 {
     void shutdown();
@@ -232,6 +245,8 @@ interface Initial
 
     void throwInnerEx() throws Inner::Ex;
     void throwInnerSubEx() throws Inner::Sub::Ex;
+
+    M opM(M v1, out M v2);
 }
 
 interface TestIntf
diff --git a/cpp/test/Ice/objects/TestI.cpp b/cpp/test/Ice/objects/TestI.cpp
index d4d99f7b330..8bd3f8ef35f 100644
--- a/cpp/test/Ice/objects/TestI.cpp
+++ b/cpp/test/Ice/objects/TestI.cpp
@@ -371,6 +371,13 @@ InitialI::throwEDerived(const Ice::Current&)
                    ICE_MAKE_SHARED(A1, "a4"));
 }
 
+Test::MPtr
+InitialI::opM(ICE_IN(Test::MPtr) v1, Test::MPtr& v2, const Ice::Current&)
+{
+    v2 = v1;
+    return v1;
+}
+
 bool
 UnexpectedObjectExceptionTestI::ice_invoke(ICE_IN(std::vector<Ice::Byte>),
                                            std::vector<Ice::Byte>& outParams,
diff --git a/cpp/test/Ice/objects/TestI.h b/cpp/test/Ice/objects/TestI.h
index 64397b0f1c4..f134202d575 100644
--- a/cpp/test/Ice/objects/TestI.h
+++ b/cpp/test/Ice/objects/TestI.h
@@ -145,6 +145,8 @@ public:
     virtual void throwInnerEx(const Ice::Current&);
     virtual void throwInnerSubEx(const Ice::Current&);
 
+    virtual Test::MPtr opM(ICE_IN(Test::MPtr), Test::MPtr&, const Ice::Current&);
+
 private:
 
     Ice::ObjectAdapterPtr _adapter;
diff --git a/csharp/test/Ice/objects/AllTests.cs b/csharp/test/Ice/objects/AllTests.cs
index 671302c8f43..98f6c968d8f 100644
--- a/csharp/test/Ice/objects/AllTests.cs
+++ b/csharp/test/Ice/objects/AllTests.cs
@@ -487,6 +487,29 @@ namespace Ice
                     var sc1 = new SC1();
                     test(sc1.id.Equals("My id"));
                     output.WriteLine("ok");
+
+                    output.Write("testing class containing complex dictionary... ");
+                    output.Flush();
+                    {
+                        var m = new Test.M();
+                        m.v = new Dictionary<StructKey, L>();
+                        var k1 = new StructKey(1, "1");
+                        m.v[k1] = new L("one");
+                        var k2 = new StructKey(2, "2");
+                        m.v[k2] = new L("two");
+                        Test.M m1;
+                        var m2 = initial.opM(m, out m1);
+                        test(m1.v.Count == 2);
+                        test(m2.v.Count == 2);
+
+                        test(m1.v[k1].data.Equals("one"));
+                        test(m2.v[k1].data.Equals("one"));
+
+                        test(m1.v[k2].data.Equals("two"));
+                        test(m2.v[k2].data.Equals("two"));
+
+                    }
+                    output.WriteLine("ok");
                     return initial;
                 }
             }
diff --git a/csharp/test/Ice/objects/InitialI.cs b/csharp/test/Ice/objects/InitialI.cs
index c96d399d943..aacaae5d355 100644
--- a/csharp/test/Ice/objects/InitialI.cs
+++ b/csharp/test/Ice/objects/InitialI.cs
@@ -194,6 +194,13 @@ namespace Ice
                 return Task.FromResult(new Test.Initial_GetAMDMBMarshaledResult(_b1, current));
             }
 
+            public override Test.M
+            opM(Test.M v1, out Test.M v2, Ice.Current current)
+            {
+                v2 = v1;
+                return v1;
+            }
+
             private Ice.ObjectAdapter _adapter;
             private Test.B _b1;
             private Test.B _b2;
diff --git a/csharp/test/Ice/objects/Test.ice b/csharp/test/Ice/objects/Test.ice
index 215b9e2a262..64ebcc98065 100644
--- a/csharp/test/Ice/objects/Test.ice
+++ b/csharp/test/Ice/objects/Test.ice
@@ -185,6 +185,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 interface Initial
 {
     void shutdown();
@@ -228,6 +241,8 @@ interface Initial
 
     void throwInnerEx() throws Inner::Ex;
     void throwInnerSubEx() throws Inner::Sub::Ex;
+
+    M opM(M v1, out M v2);
 }
 
 class Empty
diff --git a/java-compat/test/src/main/java/test/Ice/objects/AllTests.java b/java-compat/test/src/main/java/test/Ice/objects/AllTests.java
index fc2bbf83a21..40b104ade06 100644
--- a/java-compat/test/src/main/java/test/Ice/objects/AllTests.java
+++ b/java-compat/test/src/main/java/test/Ice/objects/AllTests.java
@@ -39,6 +39,9 @@ import test.Ice.objects.Test.J;
 import test.Ice.objects.Test.Recursive;
 import test.Ice.objects.Test.UnexpectedObjectExceptionTestPrx;
 import test.Ice.objects.Test.UnexpectedObjectExceptionTestPrxHelper;
+import test.Ice.objects.Test.StructKey;
+import test.Ice.objects.Test.M;
+import test.Ice.objects.Test.MHolder;
 
 public class AllTests
 {
@@ -384,6 +387,30 @@ public class AllTests
         test(communicator.getValueFactoryManager().find("TestOF") != null);
         out.println("ok");
 
+        out.print("testing class containing complex dictionary... ");
+        out.flush();
+        {
+            M m = new M();
+            m.v = new java.util.HashMap<StructKey, L>();
+            StructKey k1 = new StructKey(1, "1");
+            m.v.put(k1, new L("one"));
+            StructKey k2 = new StructKey(2, "2");
+            m.v.put(k2, new L("two"));
+
+            MHolder m1 = new MHolder();
+            M m2 = initial.opM(m, m1);
+            test(m1.value.v.size() == 2);
+            test(m2.v.size() == 2);
+
+            test(m1.value.v.get(k1).data.equals("one"));
+            test(m2.v.get(k1).data.equals("one"));
+
+            test(m1.value.v.get(k2).data.equals("two"));
+            test(m2.v.get(k2).data.equals("two"));
+
+        }
+        out.println("ok");
+
         return initial;
     }
 }
diff --git a/java-compat/test/src/main/java/test/Ice/objects/InitialI.java b/java-compat/test/src/main/java/test/Ice/objects/InitialI.java
index c1c01e93659..104c491a1ac 100644
--- a/java-compat/test/src/main/java/test/Ice/objects/InitialI.java
+++ b/java-compat/test/src/main/java/test/Ice/objects/InitialI.java
@@ -33,6 +33,8 @@ import test.Ice.objects.Test.Recursive;
 import test.Ice.objects.Test.Initial;
 import test.Ice.objects.Test.Compact;
 import test.Ice.objects.Test.CompactExt;
+import test.Ice.objects.Test.M;
+import test.Ice.objects.Test.MHolder;
 
 public final class InitialI extends Initial
 {
@@ -285,6 +287,14 @@ public final class InitialI extends Initial
         _adapter.getCommunicator().shutdown();
     }
 
+    @Override
+    public M
+    opM(M v1, MHolder v2, Ice.Current current)
+    {
+        v2.value = v1;
+        return v1;
+    }
+
     private Ice.ObjectAdapter _adapter;
     private B _b1;
     private B _b2;
diff --git a/java-compat/test/src/main/java/test/Ice/objects/Test.ice b/java-compat/test/src/main/java/test/Ice/objects/Test.ice
index 9de9aedae73..e3ae50e7acc 100644
--- a/java-compat/test/src/main/java/test/Ice/objects/Test.ice
+++ b/java-compat/test/src/main/java/test/Ice/objects/Test.ice
@@ -186,6 +186,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 class Initial
 {
     void shutdown();
@@ -229,6 +242,8 @@ class Initial
 
     void throwInnerEx() throws Inner::Ex;
     void throwInnerSubEx() throws Inner::Sub::Ex;
+
+    M opM(M v1, out M v2);
 }
 
 class Empty
diff --git a/java/test/src/main/java/test/Ice/objects/AllTests.java b/java/test/src/main/java/test/Ice/objects/AllTests.java
index 4d922616144..e4f96765d7e 100644
--- a/java/test/src/main/java/test/Ice/objects/AllTests.java
+++ b/java/test/src/main/java/test/Ice/objects/AllTests.java
@@ -37,7 +37,9 @@ import test.Ice.objects.Test.InitialPrx;
 import test.Ice.objects.Test.J;
 import test.Ice.objects.Test.Recursive;
 import test.Ice.objects.Test.UnexpectedObjectExceptionTestPrx;
-
+import test.Ice.objects.Test.M;
+import test.Ice.objects.Test.StructKey;
+import test.Ice.objects.Test.Initial.OpMResult;
 public class AllTests
 {
     private static void test(boolean b)
@@ -384,6 +386,29 @@ public class AllTests
         test(communicator.getValueFactoryManager().find("TestOF") != null);
         out.println("ok");
 
+        out.print("testing class containing complex dictionary... ");
+        out.flush();
+        {
+            M m = new M();
+            m.v = new java.util.HashMap<StructKey, L>();
+            StructKey k1 = new StructKey(1, "1");
+            m.v.put(k1, new L("one"));
+            StructKey k2 = new StructKey(2, "2");
+            m.v.put(k2, new L("two"));
+
+            Initial.OpMResult opMResult = initial.opM(m);
+            test(opMResult.returnValue.v.size() == 2);
+            test(opMResult.v2.v.size() == 2);
+
+            test(opMResult.returnValue.v.get(k1).data.equals("one"));
+            test(opMResult.v2.v.get(k1).data.equals("one"));
+
+            test(opMResult.returnValue.v.get(k2).data.equals("two"));
+            test(opMResult.v2.v.get(k2).data.equals("two"));
+
+        }
+        out.println("ok");
+
         return initial;
     }
 }
diff --git a/java/test/src/main/java/test/Ice/objects/InitialI.java b/java/test/src/main/java/test/Ice/objects/InitialI.java
index 5d0ca370165..aa86317a060 100644
--- a/java/test/src/main/java/test/Ice/objects/InitialI.java
+++ b/java/test/src/main/java/test/Ice/objects/InitialI.java
@@ -239,6 +239,15 @@ public final class InitialI implements Initial
         _adapter.getCommunicator().shutdown();
     }
 
+    @Override
+    public Initial.OpMResult opM(M v1, com.zeroc.Ice.Current current)
+    {
+        Initial.OpMResult r = new Initial.OpMResult();
+        r.returnValue = v1;
+        r.v2 = v1;
+        return r;
+    }
+
     private com.zeroc.Ice.ObjectAdapter _adapter;
     private B _b1;
     private B _b2;
diff --git a/java/test/src/main/java/test/Ice/objects/Test.ice b/java/test/src/main/java/test/Ice/objects/Test.ice
index dbacc63b28f..7e70876c7a0 100644
--- a/java/test/src/main/java/test/Ice/objects/Test.ice
+++ b/java/test/src/main/java/test/Ice/objects/Test.ice
@@ -186,6 +186,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 interface Initial
 {
     void shutdown();
@@ -229,6 +242,8 @@ interface Initial
 
     void throwInnerEx() throws Inner::Ex;
     void throwInnerSubEx() throws Inner::Sub::Ex;
+
+    M opM(M v1, out M v2);
 }
 
 class Empty
diff --git a/js/test/Ice/objects/Client.js b/js/test/Ice/objects/Client.js
index 4c380782341..abe7f76c3d5 100644
--- a/js/test/Ice/objects/Client.js
+++ b/js/test/Ice/objects/Client.js
@@ -446,6 +446,29 @@
             test(communicator.getValueFactoryManager().find("TestOF") !== null);
             out.writeLine("ok");
 
+            out.write("testing class containing complex dictionary... ");
+            {
+                let m = new Test.M();
+                m.v = new Test.MMap();
+                let k1 = new Test.StructKey(1, "1");
+                m.v.put(k1, new Test.L("one"));
+                let k2 = new Test.StructKey(2, "2");
+                m.v.put(k2, new L("two"));
+
+                let [m1, m2] = initial.opM(m);
+
+                test(m1.v.size == 2);
+                test(m2.v.size == 2);
+
+                test(m1.v.get(k1).data == "one");
+                test(m2.v.get(k1).data == "one");
+
+                test(m1.v.get(k2).data == "two");
+                test(m2.v.get(k2).data == "two");
+
+            }
+            out.println("ok");
+
             await initial.shutdown();
         }
 
diff --git a/js/test/Ice/objects/Test.ice b/js/test/Ice/objects/Test.ice
index b7b6183b629..6b834af5d25 100644
--- a/js/test/Ice/objects/Test.ice
+++ b/js/test/Ice/objects/Test.ice
@@ -189,6 +189,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 interface Initial
 {
     void shutdown();
@@ -232,6 +245,8 @@ interface Initial
 
     void throwInnerEx() throws Inner::Ex;
     void throwInnerSubEx() throws Inner::Sub::Ex;
+
+    M opM(M v1, out M v2);
 }
 
 class Empty
diff --git a/matlab/test/Ice/objects/AllTests.m b/matlab/test/Ice/objects/AllTests.m
index d2e5a7aa619..cc919e69ef7 100644
--- a/matlab/test/Ice/objects/AllTests.m
+++ b/matlab/test/Ice/objects/AllTests.m
@@ -258,6 +258,26 @@ classdef AllTests
             end
             fprintf('ok\n');
 
+            fprintf('testing class containing complex dictionary... ');
+            m = M();
+            m.v(1).key = StructKey(1, "1");
+            m.v(1).value = L("one");
+
+            m.v(2).key = StructKey(2, "2");
+            m.v(2).value = L("two");
+
+            [m1, m2] = initial.opM(m);
+
+            assert(length(m1.v) == 2);
+            assert(length(m2.v) == 2);
+
+            assert(strcmp(m1.v(1).value.data, "one"));
+            assert(strcmp(m1.v(2).value.data, "two"));
+
+            assert(strcmp(m2.v(1).value.data, "one"));
+            assert(strcmp(m2.v(2).value.data, "two"));
+
+            fprintf('ok\n');
             r = initial;
         end
     end
diff --git a/matlab/test/Ice/objects/Test.ice b/matlab/test/Ice/objects/Test.ice
index 2efe8719097..233bb9c3624 100644
--- a/matlab/test/Ice/objects/Test.ice
+++ b/matlab/test/Ice/objects/Test.ice
@@ -185,6 +185,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 interface Initial
 {
     void shutdown();
@@ -228,6 +241,8 @@ interface Initial
 
     void throwInnerEx() throws Inner::Ex;
     void throwInnerSubEx() throws Inner::Sub::Ex;
+
+    M opM(M v1, out M v2);
 }
 
 class Empty
diff --git a/objective-c/test/Ice/objects/AllTests.m b/objective-c/test/Ice/objects/AllTests.m
index 5cce3c6e940..d5e1c91b11f 100644
--- a/objective-c/test/Ice/objects/AllTests.m
+++ b/objective-c/test/Ice/objects/AllTests.m
@@ -670,5 +670,28 @@ objectsAllTests(id<ICECommunicator> communicator, BOOL collocated)
         // cross-test server does not implement this object
     }
 
+    {
+        tprintf("testing class containing a complex dictionary... ");
+        TestObjectsMutableLMap* v = [TestObjectsMutableLMap dictionary];
+        TestObjectsStructKey* k1 = [[TestObjectsStructKey alloc] init:1 s:@"1"];
+        [v setObject:[[TestObjectsL alloc] init:@"one"] forKey:k1];
+        TestObjectsStructKey* k2 = [[TestObjectsStructKey alloc] init:2 s:@"2"];
+        [v setObject:[[TestObjectsL alloc] init:@"two"] forKey:k2];
+        TestObjectsM* m = [[TestObjectsM alloc] init:v];
+
+        TestObjectsM* m1;
+        TestObjectsM* m2 = [initial opM:m v2:&m1];
+        test([m1.v count] == 2);
+        test([m2.v count] == 2);
+
+        test([((TestObjectsL*)[m1.v objectForKey:k1]).data isEqualToString:@"one"]);
+        test([((TestObjectsL*)[m1.v objectForKey:k2]).data isEqualToString:@"two"]);
+
+        test([((TestObjectsL*)[m2.v objectForKey:k1]).data isEqualToString:@"one"]);
+        test([((TestObjectsL*)[m2.v objectForKey:k2]).data isEqualToString:@"two"]);
+
+        tprintf("ok\n");
+    }
+
     return initial;
 }
diff --git a/objective-c/test/Ice/objects/ObjectsTest.ice b/objective-c/test/Ice/objects/ObjectsTest.ice
index 955e21198b7..b9fb200ccd8 100644
--- a/objective-c/test/Ice/objects/ObjectsTest.ice
+++ b/objective-c/test/Ice/objects/ObjectsTest.ice
@@ -200,6 +200,19 @@ class K
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 class Initial
 {
     void shutdown();
@@ -255,6 +268,7 @@ class Initial
     ObjectPrxDict getObjectPrxDict(ObjectPrxDict d);
     BaseDict getBaseDict(BaseDict d);
     BasePrxDict getBasePrxDict(BasePrxDict d);
+    M opM(M v1, out M v2);
 }
 
 interface TestIntf
diff --git a/objective-c/test/Ice/objects/TestI.h b/objective-c/test/Ice/objects/TestI.h
index 253b50830f2..62204d8cbf1 100644
--- a/objective-c/test/Ice/objects/TestI.h
+++ b/objective-c/test/Ice/objects/TestI.h
@@ -71,6 +71,7 @@
 -(TestObjectsObjectPrxDict *) getObjectPrxDict:(TestObjectsMutableObjectPrxDict *)d current:(ICECurrent *)current;
 -(TestObjectsBaseDict *) getBaseDict:(TestObjectsMutableBaseDict *)d current:(ICECurrent *)current;
 -(TestObjectsBasePrxDict *) getBasePrxDict:(TestObjectsMutableBasePrxDict *)d current:(ICECurrent *)current;
+ -(TestObjectsM *) opM:(TestObjectsM *)v1 v2:(TestObjectsM **)v2 current:(ICECurrent *)current;
 @end
 
 @interface UnexpectedObjectExceptionTestI : ICEBlobject<ICEBlobject>
diff --git a/objective-c/test/Ice/objects/TestI.m b/objective-c/test/Ice/objects/TestI.m
index 589b1b86057..1690eb4b105 100644
--- a/objective-c/test/Ice/objects/TestI.m
+++ b/objective-c/test/Ice/objects/TestI.m
@@ -349,6 +349,12 @@
 {
     return d;
 }
+
+-(TestObjectsM *) opM:(TestObjectsM *)v1 v2:(TestObjectsM **)v2 current:(ICECurrent *)current
+{
+    *v2 = v1;
+    return v1;
+}
 @end
 
 @implementation UnexpectedObjectExceptionTestI
diff --git a/python/test/Ice/objects/AllTests.py b/python/test/Ice/objects/AllTests.py
index 5f59683ff33..2f6a5f0fee5 100644
--- a/python/test/Ice/objects/AllTests.py
+++ b/python/test/Ice/objects/AllTests.py
@@ -320,4 +320,24 @@ def allTests(helper, communicator):
     test(communicator.getValueFactoryManager().find("TestOF") != None)
     print("ok")
 
+    sys.stdout.write("testing class containing complex dictionary... ")
+    sys.stdout.flush()
+    m = Test.M()
+    m.v = {}
+    k1 = Test.StructKey(1, "1")
+    m.v[k1] = Test.L("one")
+    k2 = Test.StructKey(2, "2")
+    m.v[k2] = Test.L("two")
+    m1, m2 = initial.opM(m)
+    test(len(m1.v) == 2)
+    test(len(m2.v) == 2)
+
+    test(m1.v[k1].data == "one")
+    test(m2.v[k1].data == "one")
+
+    test(m1.v[k2].data == "two")
+    test(m2.v[k2].data == "two")
+
+    print("ok")
+
     return initial
diff --git a/python/test/Ice/objects/Test.ice b/python/test/Ice/objects/Test.ice
index 417891a894f..1bf545c88df 100644
--- a/python/test/Ice/objects/Test.ice
+++ b/python/test/Ice/objects/Test.ice
@@ -185,6 +185,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 interface Initial
 {
     void shutdown();
@@ -228,6 +241,8 @@ interface Initial
 
     void throwInnerEx() throws Inner::Ex;
     void throwInnerSubEx() throws Inner::Sub::Ex;
+
+    M opM(M v1, out M v2);
 }
 
 }
diff --git a/python/test/Ice/objects/TestI.py b/python/test/Ice/objects/TestI.py
index 83cb67e51a8..121ea779941 100644
--- a/python/test/Ice/objects/TestI.py
+++ b/python/test/Ice/objects/TestI.py
@@ -195,6 +195,9 @@ class InitialI(Test.Initial):
     def throwInnerSubEx(self, current=None):
         raise Test.Inner.Sub.Ex("Inner::Sub::Ex")
 
+    def opM(self, m, current=None):
+        return (m, m)
+
 class UnexpectedObjectExceptionTestI(Test.UnexpectedObjectExceptionTest):
     def op(self, current=None):
         return Test.AlsoEmpty()
diff --git a/ruby/test/Ice/objects/AllTests.rb b/ruby/test/Ice/objects/AllTests.rb
index a41df03cb91..ec2ebd0603f 100644
--- a/ruby/test/Ice/objects/AllTests.rb
+++ b/ruby/test/Ice/objects/AllTests.rb
@@ -370,5 +370,24 @@ def allTests(helper, communicator)
     test(communicator.getValueFactoryManager().find('TestOF') != nil)
     puts "ok"
 
+    print "testing class containing complex dictionary... "
+    STDOUT.flush
+    m = Test::M.new
+    m.v = {}
+    k1 = Test::StructKey.new(1, "1")
+    m.v[k1] = Test::L.new("one")
+    k2 = Test::StructKey.new(2, "2")
+    m.v[k2] = Test::L.new("two")
+    m1, m2 = initial.opM(m)
+    test(m1.v.length == 2)
+    test(m2.v.length == 2)
+
+    test(m1.v[k1].data == "one")
+    test(m2.v[k1].data == "one")
+
+    test(m1.v[k2].data == "two")
+    test(m2.v[k2].data == "two")
+    puts "ok"
+
     return initial
 end
diff --git a/ruby/test/Ice/objects/Test.ice b/ruby/test/Ice/objects/Test.ice
index 2f31f0f930d..41af54b8b5c 100644
--- a/ruby/test/Ice/objects/Test.ice
+++ b/ruby/test/Ice/objects/Test.ice
@@ -155,6 +155,19 @@ class L
 sequence<Value> ValueSeq;
 dictionary<string, Value> ValueMap;
 
+struct StructKey
+{
+    int i;
+    string s;
+}
+
+dictionary<StructKey, L> LMap;
+
+class M
+{
+    LMap v;
+}
+
 class Initial
 {
     void shutdown();
@@ -192,6 +205,8 @@ class Initial
     BaseSeq opBaseSeq(BaseSeq inSeq, out BaseSeq outSeq);
 
     Compact getCompact();
+
+    M opM(M v1, out M v2);
 }
 
 }