Fix (ICE-7923) - suppress deprecation warnings

22 files changed, 233 insertions, 249 deletions

diff --git a/cpp/test/Ice/custom/AllTests.cpp b/cpp/test/Ice/custom/AllTests.cpp
index 6d4874847aa..54c79bac846 100644
--- a/cpp/test/Ice/custom/AllTests.cpp
+++ b/cpp/test/Ice/custom/AllTests.cpp
@@ -19,18 +19,6 @@
 
 using namespace std;
 
-#ifdef ICE_CPP11_MAPPING
-//
-// Slice class C is mapped to ObjectPrx
-//
-namespace Test
-{
-typedef shared_ptr<Ice::ObjectPrx> CPrxPtr;
-typedef Ice::ObjectPrx CPrx;
-}
-#endif
-
-
 namespace
 {
 
@@ -359,17 +347,17 @@ public:
         called();
     }
 
-    void opCPrxSeq(const deque<Test::CPrxPtr>& ret, const deque<Test::CPrxPtr>& out, const InParamPtr& cookie)
+    void opDPrxSeq(const deque<Test::DPrxPtr>& ret, const deque<Test::DPrxPtr>& out, const InParamPtr& cookie)
     {
-        const deque<Test::CPrxPtr>& in = getIn<deque<Test::CPrxPtr> >(cookie);
+        const deque<Test::DPrxPtr>& in = getIn<deque<Test::DPrxPtr> >(cookie);
         test(out == in);
         test(ret == in);
         called();
     }
 
-    void opCPrxList(const list<Test::CPrxPtr>& ret, const list<Test::CPrxPtr>& out, const InParamPtr& cookie)
+    void opDPrxList(const list<Test::DPrxPtr>& ret, const list<Test::DPrxPtr>& out, const InParamPtr& cookie)
     {
-        const list<Test::CPrxPtr>& in = getIn<list<Test::CPrxPtr> >(cookie);
+        const list<Test::DPrxPtr>& in = getIn<list<Test::DPrxPtr> >(cookie);
         test(out == in);
         test(ret == in);
         called();
@@ -1045,15 +1033,15 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        deque<Test::CPrxPtr> in(5);
-        in[0] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C1:" + endp + " -t 10000"));
-        in[1] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C2:" + endp + " -t 10001"));
-        in[2] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C3:" + endp + " -t 10002"));
-        in[3] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C4:" + endp + " -t 10003"));
-        in[4] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C5:" + endp + " -t 10004"));
+        deque<Test::DPrxPtr> in(5);
+        in[0] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C1:" + endp + " -t 10000"));
+        in[1] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C2:" + endp + " -t 10001"));
+        in[2] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C3:" + endp + " -t 10002"));
+        in[3] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C4:" + endp + " -t 10003"));
+        in[4] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C5:" + endp + " -t 10004"));
 
-        deque<Test::CPrxPtr> out;
-        deque<Test::CPrxPtr> ret = t->opCPrxSeq(in, out);
+        deque<Test::DPrxPtr> out;
+        deque<Test::DPrxPtr> ret = t->opDPrxSeq(in, out);
 
 #ifdef ICE_CPP11_MAPPING
         auto op = out.begin();
@@ -1071,15 +1059,15 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        list<Test::CPrxPtr> in;
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C1:" + endp + " -t 10000")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C2:" + endp + " -t 10001")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C3:" + endp + " -t 10002")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C4:" + endp + " -t 10003")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C5:" + endp + " -t 10004")));
+        list<Test::DPrxPtr> in;
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C1:" + endp + " -t 10000")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C2:" + endp + " -t 10001")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C3:" + endp + " -t 10002")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C4:" + endp + " -t 10003")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C5:" + endp + " -t 10004")));
 
-        list<Test::CPrxPtr> out;
-        list<Test::CPrxPtr> ret = t->opCPrxList(in, out);
+        list<Test::DPrxPtr> out;
+        list<Test::DPrxPtr> ret = t->opDPrxList(in, out);
 #ifdef ICE_CPP11_MAPPING
         auto op = out.begin();
         auto rp = ret.begin();
@@ -1837,15 +1825,15 @@ allTests(const Ice::CommunicatorPtr& communicator)
         }
 
         {
-            deque<Test::CPrxPtr> in(5);
-            in[0] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C1:" + endp + " -t 10000"));
-            in[1] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C2:" + endp + " -t 10001"));
-            in[2] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C3:" + endp + " -t 10002"));
-            in[3] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C4:" + endp + " -t 10003"));
-            in[4] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C5:" + endp + " -t 10004"));
+            deque<Test::DPrxPtr> in(5);
+            in[0] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C1:" + endp + " -t 10000"));
+            in[1] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C2:" + endp + " -t 10001"));
+            in[2] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C3:" + endp + " -t 10002"));
+            in[3] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C4:" + endp + " -t 10003"));
+            in[4] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C5:" + endp + " -t 10004"));
 
 #ifdef ICE_CPP11_MAPPING
-            auto r = t->opCPrxSeqAsync(in).get();
+            auto r = t->opDPrxSeqAsync(in).get();
 
             test(r.outSeq.size() == in.size());
             test(r.returnValue.size() == in.size());
@@ -1859,24 +1847,24 @@ allTests(const Ice::CommunicatorPtr& communicator)
                 test(Ice::targetEqualTo(*rp++, i));
             }
 #else
-            deque<Test::CPrx> out;
-            Ice::AsyncResultPtr r = t->begin_opCPrxSeq(in);
-            deque<Test::CPrx> ret = t->end_opCPrxSeq(out, r);
+            deque<Test::DPrx> out;
+            Ice::AsyncResultPtr r = t->begin_opDPrxSeq(in);
+            deque<Test::DPrx> ret = t->end_opDPrxSeq(out, r);
             test(out == in);
             test(ret == in);
 #endif
         }
 
         {
-            list<Test::CPrxPtr> in;
-            in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C1:" + endp + " -t 10000")));
-            in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C2:" + endp + " -t 10001")));
-            in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C3:" + endp + " -t 10002")));
-            in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C4:" + endp + " -t 10003")));
-            in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C5:" + endp + " -t 10004")));
+            list<Test::DPrxPtr> in;
+            in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C1:" + endp + " -t 10000")));
+            in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C2:" + endp + " -t 10001")));
+            in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C3:" + endp + " -t 10002")));
+            in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C4:" + endp + " -t 10003")));
+            in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C5:" + endp + " -t 10004")));
 
 #ifdef ICE_CPP11_MAPPING
-            auto r = t->opCPrxListAsync(in).get();
+            auto r = t->opDPrxListAsync(in).get();
 
             test(r.outSeq.size() == in.size());
             test(r.returnValue.size() == in.size());
@@ -1890,9 +1878,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
                 test(Ice::targetEqualTo(*rp++, i));
             }
 #else
-            list<Test::CPrx> out;
-            Ice::AsyncResultPtr r = t->begin_opCPrxList(in);
-            list<Test::CPrx> ret = t->end_opCPrxList(out, r);
+            list<Test::DPrx> out;
+            Ice::AsyncResultPtr r = t->begin_opDPrxList(in);
+            list<Test::DPrx> ret = t->end_opDPrxList(out, r);
             test(out == in);
             test(ret == in);
 #endif
@@ -2934,19 +2922,19 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
 
     {
-        deque<Test::CPrxPtr> in(5);
-        in[0] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C1:" + endp + " -t 10000"));
-        in[1] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C2:" + endp + " -t 10001"));
-        in[2] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C3:" + endp + " -t 10002"));
-        in[3] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C4:" + endp + " -t 10003"));
-        in[4] = ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C5:" + endp + " -t 10004"));
+        deque<Test::DPrxPtr> in(5);
+        in[0] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C1:" + endp + " -t 10000"));
+        in[1] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C2:" + endp + " -t 10001"));
+        in[2] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C3:" + endp + " -t 10002"));
+        in[3] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C4:" + endp + " -t 10003"));
+        in[4] = ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C5:" + endp + " -t 10004"));
 
 #ifdef ICE_CPP11_MAPPING
 
         promise<bool> done;
 
-        t->opCPrxSeqAsync(in,
-                          [&](deque<shared_ptr<Test::CPrx>> ret, deque<shared_ptr<Test::CPrx>> out)
+        t->opDPrxSeqAsync(in,
+                          [&](deque<shared_ptr<Test::DPrx>> ret, deque<shared_ptr<Test::DPrx>> out)
                           {
                               test(ret.size() == in.size());
                               auto op = out.begin();
@@ -2966,27 +2954,27 @@ allTests(const Ice::CommunicatorPtr& communicator)
         test(done.get_future().get());
 #else
         CallbackPtr cb = new Callback();
-        Test::Callback_TestIntf_opCPrxSeqPtr callback =
-            Test::newCallback_TestIntf_opCPrxSeq(cb, &Callback::opCPrxSeq, &Callback::noEx);
-        t->begin_opCPrxSeq(in, callback, newInParam(in));
+        Test::Callback_TestIntf_opDPrxSeqPtr callback =
+            Test::newCallback_TestIntf_opDPrxSeq(cb, &Callback::opDPrxSeq, &Callback::noEx);
+        t->begin_opDPrxSeq(in, callback, newInParam(in));
         cb->check();
 #endif
     }
 
     {
-        list<Test::CPrxPtr> in;
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C1:" + endp + " -t 10000")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C2:" + endp + " -t 10001")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C3:" + endp + " -t 10002")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C4:" + endp + " -t 10003")));
-        in.push_back(ICE_UNCHECKED_CAST(Test::CPrx, communicator->stringToProxy("C5:" + endp + " -t 10004")));
+        list<Test::DPrxPtr> in;
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C1:" + endp + " -t 10000")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C2:" + endp + " -t 10001")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C3:" + endp + " -t 10002")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C4:" + endp + " -t 10003")));
+        in.push_back(ICE_UNCHECKED_CAST(Test::DPrx, communicator->stringToProxy("C5:" + endp + " -t 10004")));
 
 #ifdef ICE_CPP11_MAPPING
 
         promise<bool> done;
 
-        t->opCPrxListAsync(in,
-                           [&](list<shared_ptr<Test::CPrx>> ret, list<shared_ptr<Test::CPrx>> out)
+        t->opDPrxListAsync(in,
+                           [&](list<shared_ptr<Test::DPrx>> ret, list<shared_ptr<Test::DPrx>> out)
                            {
                                test(ret.size() == in.size());
                               auto op = out.begin();
@@ -3006,9 +2994,9 @@ allTests(const Ice::CommunicatorPtr& communicator)
         test(done.get_future().get());
 #else
         CallbackPtr cb = new Callback();
-        Test::Callback_TestIntf_opCPrxListPtr callback =
-            Test::newCallback_TestIntf_opCPrxList(cb, &Callback::opCPrxList, &Callback::noEx);
-        t->begin_opCPrxList(in, callback, newInParam(in));
+        Test::Callback_TestIntf_opDPrxListPtr callback =
+            Test::newCallback_TestIntf_opDPrxList(cb, &Callback::opDPrxList, &Callback::noEx);
+        t->begin_opDPrxList(in, callback, newInParam(in));
         cb->check();
 #endif
     }
diff --git a/cpp/test/Ice/custom/Test.ice b/cpp/test/Ice/custom/Test.ice
index 644167b1d85..7a3f65bb4e0 100644
--- a/cpp/test/Ice/custom/Test.ice
+++ b/cpp/test/Ice/custom/Test.ice
@@ -88,12 +88,13 @@ sequence<C> CSeq;
 sequence<CList> CListSeq;
 ["cpp:type:std::list< ::Test::CSeq>"] sequence<CSeq> CSeqList;
 
-sequence<C*> CPrxSeq;
-["cpp:type:std::list< ::Test::CPrx>", "cpp11:type:std::list<std::shared_ptr<Ice::ObjectPrx>>"] sequence<C*> CPrxList;
+interface D {}
+sequence<D*> DPrxSeq;
+["cpp:type:std::list< ::Test::DPrx>", "cpp11:type:std::list<std::shared_ptr<DPrx>>"] sequence<D*> DPrxList;
 
-["cpp:type:std::list< ::Test::CPrxList>"] sequence<CPrxList> CPrxListList;
-sequence<CPrxList> CPrxListSeq;
-["cpp:type:std::list< ::Test::CPrxSeq>"] sequence<CPrxSeq> CPrxSeqList;
+["cpp:type:std::list< ::Test::DPrxList>"] sequence<DPrxList> DPrxListList;
+sequence<DPrxList> DPrxListSeq;
+["cpp:type:std::list< ::Test::DPrxSeq>"] sequence<DPrxSeq> DPrxSeqList;
 
 sequence<double> DoubleSeq;
 
@@ -218,11 +219,11 @@ interface TestIntf
 
     EList opEList(EList inSeq, out EList outSeq);
 
-    ["cpp:type:std::deque< ::Test::CPrx>", "cpp11:type:std::deque<std::shared_ptr<Ice::ObjectPrx>>"] CPrxSeq
-    opCPrxSeq(["cpp:type:std::deque< ::Test::CPrx>", "cpp11:type:std::deque<std::shared_ptr<Ice::ObjectPrx>>"] CPrxSeq inSeq,
-              out ["cpp:type:std::deque< ::Test::CPrx>", "cpp11:type:std::deque<std::shared_ptr<Ice::ObjectPrx>>"] CPrxSeq outSeq);
+    ["cpp:type:std::deque< ::Test::DPrx>", "cpp11:type:std::deque<std::shared_ptr<::Test::DPrx>>"] DPrxSeq
+    opDPrxSeq(["cpp:type:std::deque< ::Test::DPrx>", "cpp11:type:std::deque<std::shared_ptr<::Test::DPrx>>"] DPrxSeq inSeq,
+              out ["cpp:type:std::deque< ::Test::DPrx>", "cpp11:type:std::deque<std::shared_ptr<::Test::DPrx>>"] DPrxSeq outSeq);
 
-    CPrxList opCPrxList(CPrxList inSeq, out CPrxList outSeq);
+    DPrxList opDPrxList(DPrxList inSeq, out DPrxList outSeq);
 
     ["cpp:type:std::deque< ::Test::CPtr>", "cpp11:type:std::deque<std::shared_ptr<Test::C>>"] CSeq
     opCSeq(["cpp:type:std::deque< ::Test::CPtr>", "cpp11:type:std::deque<std::shared_ptr<Test::C>>"] CSeq inSeq,
diff --git a/cpp/test/Ice/custom/TestAMD.ice b/cpp/test/Ice/custom/TestAMD.ice
index 156959e750d..8c821819fa0 100644
--- a/cpp/test/Ice/custom/TestAMD.ice
+++ b/cpp/test/Ice/custom/TestAMD.ice
@@ -86,12 +86,13 @@ sequence<C> CSeq;
 sequence<CList> CListSeq;
 ["cpp:type:std::list< ::Test::CSeq>"] sequence<CSeq> CSeqList;
 
-sequence<C*> CPrxSeq;
-["cpp:type:std::list< ::Test::CPrx>", "cpp11:type:std::list<std::shared_ptr<Ice::ObjectPrx>>"] sequence<C*> CPrxList;
+interface D{}
+sequence<D*> DPrxSeq;
+["cpp:type:std::list< ::Test::DPrx>", "cpp11:type:std::list<std::shared_ptr<::Test::DPrx>>"] sequence<D*> DPrxList;
 
-["cpp:type:std::list< ::Test::CPrxList>"] sequence<CPrxList> CPrxListList;
-sequence<CPrxList> CPrxListSeq;
-["cpp:type:std::list< ::Test::CPrxSeq>"] sequence<CPrxSeq> CPrxSeqList;
+["cpp:type:std::list< ::Test::DPrxList>"] sequence<DPrxList> DPrxListList;
+sequence<DPrxList> DPrxListSeq;
+["cpp:type:std::list< ::Test::DPrxSeq>"] sequence<DPrxSeq> DPrxSeqList;
 
 sequence<double> DoubleSeq;
 
@@ -205,11 +206,11 @@ struct BufferStruct
 
     EList opEList(EList inSeq, out EList outSeq);
 
-    ["cpp:type:std::deque< ::Test::CPrx>", "cpp11:type:std::deque<std::shared_ptr<Ice::ObjectPrx>>"] CPrxSeq
-    opCPrxSeq(["cpp:type:std::deque< ::Test::CPrx>", "cpp11:type:std::deque<std::shared_ptr<Ice::ObjectPrx>>"] CPrxSeq inSeq,
-              out ["cpp:type:std::deque< ::Test::CPrx>", "cpp11:type:std::deque<std::shared_ptr<Ice::ObjectPrx>>"] CPrxSeq outSeq);
+    ["cpp:type:std::deque< ::Test::DPrx>", "cpp11:type:std::deque<std::shared_ptr<::Test::DPrx>>"] DPrxSeq
+    opDPrxSeq(["cpp:type:std::deque< ::Test::DPrx>", "cpp11:type:std::deque<std::shared_ptr<::Test::DPrx>>"] DPrxSeq inSeq,
+              out ["cpp:type:std::deque< ::Test::DPrx>", "cpp11:type:std::deque<std::shared_ptr<::Test::DPrx>>"] DPrxSeq outSeq);
 
-    CPrxList opCPrxList(CPrxList inSeq, out CPrxList outSeq);
+    DPrxList opDPrxList(DPrxList inSeq, out DPrxList outSeq);
 
     ["cpp:type:std::deque< ::Test::CPtr>", "cpp11:type:std::deque<std::shared_ptr<Test::C>>"] CSeq
     opCSeq(["cpp:type:std::deque< ::Test::CPtr>", "cpp11:type:std::deque<std::shared_ptr<Test::C>>"] CSeq inSeq,
diff --git a/cpp/test/Ice/custom/TestAMDI.cpp b/cpp/test/Ice/custom/TestAMDI.cpp
index a54205383a1..3b710d9bf45 100644
--- a/cpp/test/Ice/custom/TestAMDI.cpp
+++ b/cpp/test/Ice/custom/TestAMDI.cpp
@@ -230,17 +230,17 @@ TestIntfI::opEListAsync(Test::EList in,
 }
 
 void
-TestIntfI::opCPrxSeqAsync(std::deque<std::shared_ptr<Ice::ObjectPrx>> in,
-                          std::function<void(const std::deque<std::shared_ptr<Ice::ObjectPrx>>&,
-                                              const std::deque<std::shared_ptr<Ice::ObjectPrx>>&)> response,
+TestIntfI::opDPrxSeqAsync(std::deque<std::shared_ptr<Test::DPrx>> in,
+                          std::function<void(const std::deque<std::shared_ptr<Test::DPrx>>&,
+                                             const std::deque<std::shared_ptr<Test::DPrx>>&)> response,
                           std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
 }
 
 void
-TestIntfI::opCPrxListAsync(Test::CPrxList in,
-                           std::function<void(const Test::CPrxList&, const Test::CPrxList&)> response,
+TestIntfI::opDPrxListAsync(Test::DPrxList in,
+                           std::function<void(const Test::DPrxList&, const Test::DPrxList&)> response,
                            std::function<void(std::exception_ptr)>, const Ice::Current&)
 {
     response(in, in);
@@ -585,21 +585,21 @@ TestIntfI::opEList_async(const Test::AMD_TestIntf_opEListPtr& opEListCB,
 }
 
 void
-TestIntfI::opCPrxSeq_async(const Test::AMD_TestIntf_opCPrxSeqPtr& opCPrxSeqCB,
-                           const std::deque<Test::CPrx>& inSeq,
+TestIntfI::opDPrxSeq_async(const Test::AMD_TestIntf_opDPrxSeqPtr& opDPrxSeqCB,
+                           const std::deque<Test::DPrx>& inSeq,
                            const Ice::Current&)
 {
-    std::deque<Test::CPrx> outSeq(inSeq);
-    opCPrxSeqCB->ice_response(outSeq, outSeq);
+    std::deque<Test::DPrx> outSeq(inSeq);
+    opDPrxSeqCB->ice_response(outSeq, outSeq);
 }
 
 void
-TestIntfI::opCPrxList_async(const Test::AMD_TestIntf_opCPrxListPtr& opCPrxListCB,
-                            const Test::CPrxList& inSeq,
+TestIntfI::opDPrxList_async(const Test::AMD_TestIntf_opDPrxListPtr& opDPrxListCB,
+                            const Test::DPrxList& inSeq,
                             const Ice::Current&)
 {
-    Test::CPrxList outSeq(inSeq);
-    opCPrxListCB->ice_response(outSeq, outSeq);
+    Test::DPrxList outSeq(inSeq);
+    opDPrxListCB->ice_response(outSeq, outSeq);
 }
 
 void
diff --git a/cpp/test/Ice/custom/TestAMDI.h b/cpp/test/Ice/custom/TestAMDI.h
index 0b643269641..af4d3532898 100644
--- a/cpp/test/Ice/custom/TestAMDI.h
+++ b/cpp/test/Ice/custom/TestAMDI.h
@@ -146,14 +146,14 @@ public:
                       std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
-    void opCPrxSeqAsync(std::deque<std::shared_ptr<Ice::ObjectPrx>>,
-                        std::function<void(const std::deque<std::shared_ptr<Ice::ObjectPrx>>&,
-                                            const std::deque<std::shared_ptr<Ice::ObjectPrx>>&)>,
+    void opDPrxSeqAsync(std::deque<std::shared_ptr<::Test::DPrx>>,
+                        std::function<void(const std::deque<std::shared_ptr<::Test::DPrx>>&,
+                                            const std::deque<std::shared_ptr<::Test::DPrx>>&)>,
                         std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
-    void opCPrxListAsync(::Test::CPrxList,
-                         std::function<void(const ::Test::CPrxList&, const ::Test::CPrxList&)>,
+    void opDPrxListAsync(::Test::DPrxList,
+                         std::function<void(const ::Test::DPrxList&, const ::Test::DPrxList&)>,
                          std::function<void(std::exception_ptr)>, const Ice::Current&) override;
 
 
@@ -324,12 +324,12 @@ public:
                                const Test::EList&,
                                const Ice::Current&);
 
-    virtual void opCPrxSeq_async(const Test::AMD_TestIntf_opCPrxSeqPtr&,
-                                 const std::deque<Test::CPrx>&,
+    virtual void opDPrxSeq_async(const Test::AMD_TestIntf_opDPrxSeqPtr&,
+                                 const std::deque<Test::DPrx>&,
                                  const Ice::Current&);
 
-    virtual void opCPrxList_async(const Test::AMD_TestIntf_opCPrxListPtr&,
-                                  const Test::CPrxList&,
+    virtual void opDPrxList_async(const Test::AMD_TestIntf_opDPrxListPtr&,
+                                  const Test::DPrxList&,
                                   const Ice::Current&);
 
     virtual void opCSeq_async(const Test::AMD_TestIntf_opCSeqPtr&,
diff --git a/cpp/test/Ice/custom/TestI.cpp b/cpp/test/Ice/custom/TestI.cpp
index 42915b33e51..7028b6b6412 100644
--- a/cpp/test/Ice/custom/TestI.cpp
+++ b/cpp/test/Ice/custom/TestI.cpp
@@ -331,18 +331,18 @@ TestIntfI::opEList(ICE_IN(std::list< ::Test::E>) inSeq,
     return inSeq;
 }
 
-std::deque< ::Test::CPrxPtr>
-TestIntfI::opCPrxSeq(ICE_IN(std::deque< ::Test::CPrxPtr>) inSeq,
-                           std::deque< ::Test::CPrxPtr>& outSeq,
+std::deque< ::Test::DPrxPtr>
+TestIntfI::opDPrxSeq(ICE_IN(std::deque< ::Test::DPrxPtr>) inSeq,
+                           std::deque< ::Test::DPrxPtr>& outSeq,
                            const Ice::Current&)
 {
     outSeq = inSeq;
     return inSeq;
 }
 
-std::list< ::Test::CPrxPtr>
-TestIntfI::opCPrxList(ICE_IN(std::list< ::Test::CPrxPtr>) inSeq,
-                            std::list< ::Test::CPrxPtr>& outSeq,
+std::list< ::Test::DPrxPtr>
+TestIntfI::opDPrxList(ICE_IN(std::list< ::Test::DPrxPtr>) inSeq,
+                            std::list< ::Test::DPrxPtr>& outSeq,
                             const Ice::Current&)
 {
     outSeq = inSeq;
diff --git a/cpp/test/Ice/custom/TestI.h b/cpp/test/Ice/custom/TestI.h
index 15e2de12d73..8ae965e20a6 100644
--- a/cpp/test/Ice/custom/TestI.h
+++ b/cpp/test/Ice/custom/TestI.h
@@ -12,17 +12,6 @@
 
 #include <Test.h>
 
-#ifdef ICE_CPP11_MAPPING
-//
-// Slice class C is mapped to ObjectPrx
-//
-namespace Test
-{
-typedef std::shared_ptr<Ice::ObjectPrx> CPrxPtr;
-}
-
-#endif
-
 class TestIntfI : public virtual Test::TestIntf
 {
 public:
@@ -169,12 +158,12 @@ public:
                                           std::list< ::Test::E>&,
                                           const Ice::Current&);
 
-    virtual std::deque< ::Test::CPrxPtr> opCPrxSeq(ICE_IN(std::deque< ::Test::CPrxPtr>),
-                                                std::deque< ::Test::CPrxPtr>&,
+    virtual std::deque< ::Test::DPrxPtr> opDPrxSeq(ICE_IN(std::deque< ::Test::DPrxPtr>),
+                                                std::deque< ::Test::DPrxPtr>&,
                                                 const Ice::Current&);
 
-    virtual std::list< ::Test::CPrxPtr> opCPrxList(ICE_IN(std::list< ::Test::CPrxPtr>),
-                                                std::list< ::Test::CPrxPtr>&,
+    virtual std::list< ::Test::DPrxPtr> opDPrxList(ICE_IN(std::list< ::Test::DPrxPtr>),
+                                                std::list< ::Test::DPrxPtr>&,
                                                 const Ice::Current&);
 
     virtual std::deque< ::Test::CPtr> opCSeq(ICE_IN(std::deque< ::Test::CPtr>),
diff --git a/cpp/test/Ice/impl/Test.ice b/cpp/test/Ice/impl/Test.ice
index 35a26eb85eb..1cb1d5ca8e7 100644
--- a/cpp/test/Ice/impl/Test.ice
+++ b/cpp/test/Ice/impl/Test.ice
@@ -267,14 +267,14 @@ interface MyClass
 struct MyStruct1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myStruct1; // Same name as the enclosing struct
 }
 
 class MyClass1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myClass1; // Same name as the enclosing class
 }
 
diff --git a/cpp/test/Ice/operations/Test.ice b/cpp/test/Ice/operations/Test.ice
index 355348a5ec9..002788abd0c 100644
--- a/cpp/test/Ice/operations/Test.ice
+++ b/cpp/test/Ice/operations/Test.ice
@@ -269,14 +269,14 @@ interface MyClass
 struct MyStruct1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myStruct1; // Same name as the enclosing struct
 }
 
 class MyClass1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myClass1; // Same name as the enclosing class
 }
 
diff --git a/csharp/test/Ice/seqMapping/MyClassAMDI.cs b/csharp/test/Ice/seqMapping/MyClassAMDI.cs
index b8e5cb24d9c..6a4d67d25ff 100644
--- a/csharp/test/Ice/seqMapping/MyClassAMDI.cs
+++ b/csharp/test/Ice/seqMapping/MyClassAMDI.cs
@@ -373,34 +373,34 @@ public sealed class MyClassI : MyClassDisp_
         return Task.FromResult<MyClass_OpLCVSResult>(new MyClass_OpLCVSResult(i, i));
     }
 
-    public override Task<MyClass_OpACVPrxSResult>
-    opACVPrxSAsync(Ice.ObjectPrx[] i, Ice.Current current)
+    public override Task<MyClass_OpAIPrxSResult>
+    opAIPrxSAsync(Test.IPrx[] i, Ice.Current current)
     {
-        return Task.FromResult<MyClass_OpACVPrxSResult>(new MyClass_OpACVPrxSResult(i, i));
+        return Task.FromResult<MyClass_OpAIPrxSResult>(new MyClass_OpAIPrxSResult(i, i));
     }
 
-    public override Task<MyClass_OpLCVPrxSResult>
-    opLCVPrxSAsync(List<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpLIPrxSResult>
+    opLIPrxSAsync(List<Test.IPrx> i, Ice.Current current)
     {
-        return Task.FromResult<MyClass_OpLCVPrxSResult>(new MyClass_OpLCVPrxSResult(i, i));
+        return Task.FromResult<MyClass_OpLIPrxSResult>(new MyClass_OpLIPrxSResult(i, i));
     }
 
-    public override Task<MyClass_OpKCVPrxSResult>
-    opKCVPrxSAsync(LinkedList<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpKIPrxSResult>
+    opKIPrxSAsync(LinkedList<Test.IPrx> i, Ice.Current current)
     {
-        return Task.FromResult<MyClass_OpKCVPrxSResult>(new MyClass_OpKCVPrxSResult(i, i));
+        return Task.FromResult<MyClass_OpKIPrxSResult>(new MyClass_OpKIPrxSResult(i, i));
     }
 
-    public override Task<MyClass_OpQCVPrxSResult>
-    opQCVPrxSAsync(Queue<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpQIPrxSResult>
+    opQIPrxSAsync(Queue<Test.IPrx> i, Ice.Current current)
     {
-        return Task.FromResult<MyClass_OpQCVPrxSResult>(new MyClass_OpQCVPrxSResult(i, i));
+        return Task.FromResult<MyClass_OpQIPrxSResult>(new MyClass_OpQIPrxSResult(i, i));
     }
 
-    public override Task<MyClass_OpSCVPrxSResult>
-    opSCVPrxSAsync(Stack<Ice.ObjectPrx> i, Ice.Current current)
+    public override Task<MyClass_OpSIPrxSResult>
+    opSIPrxSAsync(Stack<Test.IPrx> i, Ice.Current current)
     {
-        return Task.FromResult<MyClass_OpSCVPrxSResult>(new MyClass_OpSCVPrxSResult(i, i));
+        return Task.FromResult<MyClass_OpSIPrxSResult>(new MyClass_OpSIPrxSResult(i, i));
     }
 
     public override Task<MyClass_OpACRSResult>
diff --git a/csharp/test/Ice/seqMapping/MyClassI.cs b/csharp/test/Ice/seqMapping/MyClassI.cs
index 7b32974227c..67519633197 100644
--- a/csharp/test/Ice/seqMapping/MyClassI.cs
+++ b/csharp/test/Ice/seqMapping/MyClassI.cs
@@ -413,31 +413,31 @@ public sealed class MyClassI : Test.MyClassDisp_
         return i;
     }
 
-    public override Ice.ObjectPrx[] opACVPrxS(Ice.ObjectPrx[] i, out Ice.ObjectPrx[] o, Ice.Current current)
+    public override Test.IPrx[] opAIPrxS(Test.IPrx[] i, out Test.IPrx[] o, Ice.Current current)
     {
         o = i;
         return i;
     }
 
-    public override List<Ice.ObjectPrx> opLCVPrxS(List<Ice.ObjectPrx> i, out List<Ice.ObjectPrx> o, Ice.Current current)
+    public override List<Test.IPrx> opLIPrxS(List<Test.IPrx> i, out List<Test.IPrx> o, Ice.Current current)
     {
         o = i;
         return i;
     }
 
-    public override LinkedList<Ice.ObjectPrx> opKCVPrxS(LinkedList<Ice.ObjectPrx> i, out LinkedList<Ice.ObjectPrx> o, Ice.Current current)
+    public override LinkedList<Test.IPrx> opKIPrxS(LinkedList<Test.IPrx> i, out LinkedList<Test.IPrx> o, Ice.Current current)
     {
         o = i;
         return i;
     }
 
-    public override Queue<Ice.ObjectPrx> opQCVPrxS(Queue<Ice.ObjectPrx> i, out Queue<Ice.ObjectPrx> o, Ice.Current current)
+    public override Queue<Test.IPrx> opQIPrxS(Queue<Test.IPrx> i, out Queue<Test.IPrx> o, Ice.Current current)
     {
         o = i;
         return i;
     }
 
-    public override Stack<Ice.ObjectPrx> opSCVPrxS(Stack<Ice.ObjectPrx> i, out Stack<Ice.ObjectPrx> o, Ice.Current current)
+    public override Stack<Test.IPrx> opSIPrxS(Stack<Test.IPrx> i, out Stack<Test.IPrx> o, Ice.Current current)
     {
         o = i;
         return i;
diff --git a/csharp/test/Ice/seqMapping/Test.ice b/csharp/test/Ice/seqMapping/Test.ice
index d7985722fbe..fdd62452b7a 100644
--- a/csharp/test/Ice/seqMapping/Test.ice
+++ b/csharp/test/Ice/seqMapping/Test.ice
@@ -111,12 +111,13 @@ class CV
 sequence<CV> ACVS;
 ["clr:generic:List"] sequence<CV> LCVS;
 
-sequence<CV*> ACVPrxS;
-["clr:generic:List"] sequence<CV*> LCVPrxS;
-["clr:generic:LinkedList"] sequence<CV*> KCVPrxS;
-["clr:generic:Queue"] sequence<CV*> QCVPrxS;
-["clr:generic:Stack"] sequence<CV*> SCVPrxS;
-["clr:generic:Custom"] sequence<CV*> CCVPrxS;
+interface I {}
+sequence<I*> AIPrxS;
+["clr:generic:List"] sequence<I*> LIPrxS;
+["clr:generic:LinkedList"] sequence<I*> KIPrxS;
+["clr:generic:Queue"] sequence<I*> QIPrxS;
+["clr:generic:Stack"] sequence<I*> SIPrxS;
+["clr:generic:Custom"] sequence<I*> CIPrxS;
 
 class CR
 {
@@ -231,11 +232,11 @@ interface MyClass
     QEnS opQEnS(QEnS i, out QEnS o);
     SEnS opSEnS(SEnS i, out SEnS o);
 
-    ACVPrxS opACVPrxS(ACVPrxS i, out ACVPrxS o);
-    LCVPrxS opLCVPrxS(LCVPrxS i, out LCVPrxS o);
-    KCVPrxS opKCVPrxS(KCVPrxS i, out KCVPrxS o);
-    QCVPrxS opQCVPrxS(QCVPrxS i, out QCVPrxS o);
-    SCVPrxS opSCVPrxS(SCVPrxS i, out SCVPrxS o);
+    AIPrxS opAIPrxS(AIPrxS i, out AIPrxS o);
+    LIPrxS opLIPrxS(LIPrxS i, out LIPrxS o);
+    KIPrxS opKIPrxS(KIPrxS i, out KIPrxS o);
+    QIPrxS opQIPrxS(QIPrxS i, out QIPrxS o);
+    SIPrxS opSIPrxS(SIPrxS i, out SIPrxS o);
 
     CustomIntS opCustomIntS(CustomIntS i, out CustomIntS o);
     CustomCVS opCustomCVS(CustomCVS i, out CustomCVS o);
diff --git a/csharp/test/Ice/seqMapping/TestAMD.ice b/csharp/test/Ice/seqMapping/TestAMD.ice
index 73c76ab9faf..64e5b67af81 100644
--- a/csharp/test/Ice/seqMapping/TestAMD.ice
+++ b/csharp/test/Ice/seqMapping/TestAMD.ice
@@ -99,11 +99,12 @@ class CV
 sequence<CV> ACVS;
 ["clr:generic:List"] sequence<CV> LCVS;
 
-sequence<CV*> ACVPrxS;
-["clr:generic:List"] sequence<CV*> LCVPrxS;
-["clr:generic:LinkedList"] sequence<CV*> KCVPrxS;
-["clr:generic:Queue"] sequence<CV*> QCVPrxS;
-["clr:generic:Stack"] sequence<CV*> SCVPrxS;
+interface I {}
+sequence<I*> AIPrxS;
+["clr:generic:List"] sequence<I*> LIPrxS;
+["clr:generic:LinkedList"] sequence<I*> KIPrxS;
+["clr:generic:Queue"] sequence<I*> QIPrxS;
+["clr:generic:Stack"] sequence<I*> SIPrxS;
 
 class CR
 {
@@ -216,11 +217,11 @@ sequence<En> AEnS;
     QEnS opQEnS(QEnS i, out QEnS o);
     SEnS opSEnS(SEnS i, out SEnS o);
 
-    ACVPrxS opACVPrxS(ACVPrxS i, out ACVPrxS o);
-    LCVPrxS opLCVPrxS(LCVPrxS i, out LCVPrxS o);
-    KCVPrxS opKCVPrxS(KCVPrxS i, out KCVPrxS o);
-    QCVPrxS opQCVPrxS(QCVPrxS i, out QCVPrxS o);
-    SCVPrxS opSCVPrxS(SCVPrxS i, out SCVPrxS o);
+    AIPrxS opAIPrxS(AIPrxS i, out AIPrxS o);
+    LIPrxS opLIPrxS(LIPrxS i, out LIPrxS o);
+    KIPrxS opKIPrxS(KIPrxS i, out KIPrxS o);
+    QIPrxS opQIPrxS(QIPrxS i, out QIPrxS o);
+    SIPrxS opSIPrxS(SIPrxS i, out SIPrxS o);
 
     CustomIntS opCustomIntS(CustomIntS i, out CustomIntS o);
     CustomCVS opCustomCVS(CustomCVS i, out CustomCVS o);
diff --git a/csharp/test/Ice/seqMapping/Twoways.cs b/csharp/test/Ice/seqMapping/Twoways.cs
index d20c95afc37..7ddb3065133 100644
--- a/csharp/test/Ice/seqMapping/Twoways.cs
+++ b/csharp/test/Ice/seqMapping/Twoways.cs
@@ -1061,75 +1061,75 @@ class Twoways
         }
 
         {
-            Ice.ObjectPrx[] i = new Ice.ObjectPrx[_length];
+            Test.IPrx[] i = new Test.IPrx[_length];
             for(int c = 0; c < _length; ++c)
             {
-                i[c] = communicator.stringToProxy(c.ToString());
+                i[c] = Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()));
             }
-            Ice.ObjectPrx[] o;
-            Ice.ObjectPrx[] r;
+            Test.IPrx[] o;
+            Test.IPrx[] r;
 
-            r = p.opACVPrxS(i, out o);
+            r = p.opAIPrxS(i, out o);
 
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
         }
 
         {
-            List<Ice.ObjectPrx> i = new List<Ice.ObjectPrx>(_length);
+            List<Test.IPrx> i = new List<Test.IPrx>(_length);
             for(int c = 0; c < _length; ++c)
             {
-                i.Add(communicator.stringToProxy(c.ToString()));
+                i.Add(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
-            List<Ice.ObjectPrx> o;
-            List<Ice.ObjectPrx> r;
+            List<Test.IPrx> o;
+            List<Test.IPrx> r;
 
-            r = p.opLCVPrxS(i, out o);
+            r = p.opLIPrxS(i, out o);
 
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
         }
 
         {
-            LinkedList<Ice.ObjectPrx> i = new LinkedList<Ice.ObjectPrx>();
+            LinkedList<Test.IPrx> i = new LinkedList<Test.IPrx>();
             for(int c = 0; c < _length; ++c)
             {
-                i.AddLast(communicator.stringToProxy(c.ToString()));
+                i.AddLast(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
-            LinkedList<Ice.ObjectPrx> o;
-            LinkedList<Ice.ObjectPrx> r;
+            LinkedList<Test.IPrx> o;
+            LinkedList<Test.IPrx> r;
 
-            r = p.opKCVPrxS(i, out o);
+            r = p.opKIPrxS(i, out o);
 
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
         }
 
         {
-            Queue<Ice.ObjectPrx> i = new Queue<Ice.ObjectPrx>();
+            Queue<Test.IPrx> i = new Queue<Test.IPrx>();
             for(int c = 0; c < _length; ++c)
             {
-                i.Enqueue(communicator.stringToProxy(c.ToString()));
+                i.Enqueue(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
-            Queue<Ice.ObjectPrx> o;
-            Queue<Ice.ObjectPrx> r;
+            Queue<Test.IPrx> o;
+            Queue<Test.IPrx> r;
 
-            r = p.opQCVPrxS(i, out o);
+            r = p.opQIPrxS(i, out o);
 
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
         }
 
         {
-            Stack<Ice.ObjectPrx> i = new Stack<Ice.ObjectPrx>();
+            Stack<Test.IPrx> i = new Stack<Test.IPrx>();
             for(int c = 0; c < _length; ++c)
             {
-                i.Push(communicator.stringToProxy(c.ToString()));
+                i.Push(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
-            Stack<Ice.ObjectPrx> o;
-            Stack<Ice.ObjectPrx> r;
+            Stack<Test.IPrx> o;
+            Stack<Test.IPrx> r;
 
-            r = p.opSCVPrxS(i, out o);
+            r = p.opSIPrxS(i, out o);
 
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
diff --git a/csharp/test/Ice/seqMapping/TwowaysAMI.cs b/csharp/test/Ice/seqMapping/TwowaysAMI.cs
index f604838ad4f..2adb9cbbd45 100644
--- a/csharp/test/Ice/seqMapping/TwowaysAMI.cs
+++ b/csharp/test/Ice/seqMapping/TwowaysAMI.cs
@@ -677,52 +677,52 @@ public class TwowaysAMI
             callback.called();
         }
 
-        public void opACVPrxSI(Ice.AsyncResult result)
+        public void opIPrxSI(Ice.AsyncResult result)
         {
-            Ice.ObjectPrx[] i = (Ice.ObjectPrx[])result.AsyncState;
-            Ice.ObjectPrx[] o;
-            Ice.ObjectPrx[] r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opACVPrxS(out o, result);
+            Test.IPrx[] i = (Test.IPrx[])result.AsyncState;
+            Test.IPrx[] o;
+            Test.IPrx[] r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opAIPrxS(out o, result);
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
             callback.called();
         }
 
-        public void opLCVPrxSI(Ice.AsyncResult result)
+        public void opLIPrxSI(Ice.AsyncResult result)
         {
-            List<Ice.ObjectPrx> i = (List<Ice.ObjectPrx>)result.AsyncState;
-            List<Ice.ObjectPrx> o;
-            List<Ice.ObjectPrx> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLCVPrxS(out o, result);
+            List<Test.IPrx> i = (List<Test.IPrx>)result.AsyncState;
+            List<Test.IPrx> o;
+            List<Test.IPrx> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opLIPrxS(out o, result);
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
             callback.called();
         }
 
-        public void opKCVPrxSI(Ice.AsyncResult result)
+        public void opKIPrxSI(Ice.AsyncResult result)
         {
-            LinkedList<Ice.ObjectPrx> i = (LinkedList<Ice.ObjectPrx>)result.AsyncState;
-            LinkedList<Ice.ObjectPrx> o;
-            LinkedList<Ice.ObjectPrx> r =
-                MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKCVPrxS(out o, result);
+            LinkedList<Test.IPrx> i = (LinkedList<Test.IPrx>)result.AsyncState;
+            LinkedList<Test.IPrx> o;
+            LinkedList<Test.IPrx> r =
+                MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opKIPrxS(out o, result);
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
             callback.called();
         }
 
-        public void opQCVPrxSI(Ice.AsyncResult result)
+        public void opQIPrxSI(Ice.AsyncResult result)
         {
-            Queue<Ice.ObjectPrx> i = (Queue<Ice.ObjectPrx>)result.AsyncState;
-            Queue<Ice.ObjectPrx> o;
-            Queue<Ice.ObjectPrx> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQCVPrxS(out o, result);
+            Queue<Test.IPrx> i = (Queue<Test.IPrx>)result.AsyncState;
+            Queue<Test.IPrx> o;
+            Queue<Test.IPrx> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opQIPrxS(out o, result);
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
             callback.called();
         }
 
-        public void opSCVPrxSI(Ice.AsyncResult result)
+        public void opSIPrxSI(Ice.AsyncResult result)
         {
-            Stack<Ice.ObjectPrx> i = (Stack<Ice.ObjectPrx>)result.AsyncState;
-            Stack<Ice.ObjectPrx> o;
-            Stack<Ice.ObjectPrx> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSCVPrxS(out o, result);
+            Stack<Test.IPrx> i = (Stack<Test.IPrx>)result.AsyncState;
+            Stack<Test.IPrx> o;
+            Stack<Test.IPrx> r = MyClassPrxHelper.uncheckedCast(result.getProxy()).end_opSIPrxS(out o, result);
             test(Ice.CollectionComparer.Equals(i, o));
             test(Ice.CollectionComparer.Equals(i, r));
             callback.called();
@@ -1646,62 +1646,62 @@ public class TwowaysAMI
         }
 
         {
-            Ice.ObjectPrx[] i = new Ice.ObjectPrx[_length];
+            Test.IPrx[] i = new Test.IPrx[_length];
             for(int c = 0; c < _length; ++c)
             {
-                i[c] = communicator.stringToProxy(c.ToString());
+                i[c] = Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString()));
             }
 
             Callback cb = new Callback();
-            p.begin_opACVPrxS(i, null, cb.opACVPrxSI, i);
+            p.begin_opAIPrxS(i, null, cb.opIPrxSI, i);
             cb.check();
         }
 
         {
-            List<Ice.ObjectPrx> i = new List<Ice.ObjectPrx>();
+            List<Test.IPrx> i = new List<Test.IPrx>();
             for(int c = 0; c < _length; ++c)
             {
-                i.Add(communicator.stringToProxy(c.ToString()));
+                i.Add(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
 
             Callback cb = new Callback();
-            p.begin_opLCVPrxS(i, null, cb.opLCVPrxSI, i);
+            p.begin_opLIPrxS(i, null, cb.opLIPrxSI, i);
             cb.check();
         }
 
         {
-            LinkedList<Ice.ObjectPrx> i = new LinkedList<Ice.ObjectPrx>();
+            LinkedList<Test.IPrx> i = new LinkedList<Test.IPrx>();
             for(int c = 0; c < _length; ++c)
             {
-                i.AddLast(communicator.stringToProxy(c.ToString()));
+                i.AddLast(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
 
             Callback cb = new Callback();
-            p.begin_opKCVPrxS(i, null, cb.opKCVPrxSI, i);
+            p.begin_opKIPrxS(i, null, cb.opKIPrxSI, i);
             cb.check();
         }
 
         {
-            Queue<Ice.ObjectPrx> i = new Queue<Ice.ObjectPrx>();
+            Queue<Test.IPrx> i = new Queue<Test.IPrx>();
             for(int c = 0; c < _length; ++c)
             {
-                i.Enqueue(communicator.stringToProxy(c.ToString()));
+                i.Enqueue(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
 
             Callback cb = new Callback();
-            p.begin_opQCVPrxS(i, null, cb.opQCVPrxSI, i);
+            p.begin_opQIPrxS(i, null, cb.opQIPrxSI, i);
             cb.check();
         }
 
         {
-            Stack<Ice.ObjectPrx> i = new Stack<Ice.ObjectPrx>();
+            Stack<Test.IPrx> i = new Stack<Test.IPrx>();
             for(int c = 0; c < _length; ++c)
             {
-                i.Push(communicator.stringToProxy(c.ToString()));
+                i.Push(Test.IPrxHelper.uncheckedCast(communicator.stringToProxy(c.ToString())));
             }
 
             Callback cb = new Callback();
-            p.begin_opSCVPrxS(i, null, cb.opSCVPrxSI, i);
+            p.begin_opSIPrxS(i, null, cb.opSIPrxSI, i);
             cb.check();
         }
 
diff --git a/csharp/test/Ice/stream/Test.ice b/csharp/test/Ice/stream/Test.ice
index 3e6172400eb..5671c834eed 100644
--- a/csharp/test/Ice/stream/Test.ice
+++ b/csharp/test/Ice/stream/Test.ice
@@ -12,7 +12,7 @@
 //
 // Suppress invalid metadata warnings
 //
-[["suppress-warning:invalid-metadata"]]
+[["suppress-warning:invalid-metadata, deprecated"]]
 
 #include <Ice/BuiltinSequences.ice>
 
diff --git a/objective-c/test/Ice/operations/OperationsTest.ice b/objective-c/test/Ice/operations/OperationsTest.ice
index 6029218c450..0186627b3b7 100644
--- a/objective-c/test/Ice/operations/OperationsTest.ice
+++ b/objective-c/test/Ice/operations/OperationsTest.ice
@@ -308,14 +308,14 @@ interface MyClass
 struct MyStruct1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myStruct1; // Same name as the enclosing struct
 }
 
 class MyClass1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myClass1; // Same name as the enclosing class
 }
 
diff --git a/objective-c/test/Ice/optional/OptionalTest.ice b/objective-c/test/Ice/optional/OptionalTest.ice
index 339c33d579c..b69e2d85aec 100644
--- a/objective-c/test/Ice/optional/OptionalTest.ice
+++ b/objective-c/test/Ice/optional/OptionalTest.ice
@@ -9,7 +9,7 @@
 
 #pragma once
 
-[["cpp:include:list"]]
+[["cpp:include:list", "suppress-warning:deprecated"]]
 
 ["objc:prefix:TestOptional"]
 module Test
diff --git a/objective-c/test/Ice/stream/StreamTest.ice b/objective-c/test/Ice/stream/StreamTest.ice
index 2d4c00391be..55fc031f55c 100644
--- a/objective-c/test/Ice/stream/StreamTest.ice
+++ b/objective-c/test/Ice/stream/StreamTest.ice
@@ -22,6 +22,7 @@ enum MyEnum
     enum3
 }
 
+interface MyInterface;
 class MyClass;
 
 ["cpp:comparable"] struct SmallStruct
@@ -35,7 +36,7 @@ class MyClass;
     double d;
     string str;
     MyEnum e;
-    MyClass* p;
+    MyInterface* p;
 }
 
 ["cpp:class"] struct ClassStruct
diff --git a/ruby/test/Ice/operations/Test.ice b/ruby/test/Ice/operations/Test.ice
index 15e894176b3..228bd522429 100644
--- a/ruby/test/Ice/operations/Test.ice
+++ b/ruby/test/Ice/operations/Test.ice
@@ -261,14 +261,14 @@ interface MyClass
 struct MyStruct1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myStruct1; // Same name as the enclosing struct
 }
 
 class MyClass1
 {
     string tesT; // Same name as the enclosing module
-    MyClass myClass; // Same name as an already defined class
+    MyClass* myClass; // Same name as an already defined class
     string myClass1; // Same name as the enclosing class
 }
 
diff --git a/ruby/test/Ice/optional/Test.ice b/ruby/test/Ice/optional/Test.ice
index 0bc0290fbb4..a9764dc813d 100644
--- a/ruby/test/Ice/optional/Test.ice
+++ b/ruby/test/Ice/optional/Test.ice
@@ -9,6 +9,8 @@
 
 #pragma once
 
+[["suppress-warning:deprecated"]]
+
 module Test
 {
 
diff --git a/ruby/test/Slice/escape/Key.ice b/ruby/test/Slice/escape/Key.ice
index 2b9effe3101..3d1ca743b74 100644
--- a/ruby/test/Slice/escape/Key.ice
+++ b/ruby/test/Slice/escape/Key.ice
@@ -7,7 +7,7 @@
 //
 // **********************************************************************
 
-[["underscore"]]
+[["underscore", "suppress-warning:deprecated"]]
 
 module BEGIN
 {