Fixed ICE-8132 - Ice/slicing/exceptions failure with UWP/SSL

17 files changed, 645 insertions, 602 deletions

diff --git a/cpp/test/Ice/slicing/exceptions/AllTests.cpp b/cpp/test/Ice/slicing/exceptions/AllTests.cpp
index bb799e9148b..abc1692e45c 100644
--- a/cpp/test/Ice/slicing/exceptions/AllTests.cpp
+++ b/cpp/test/Ice/slicing/exceptions/AllTests.cpp
@@ -1039,123 +1039,124 @@ allTests(const Ice::CommunicatorPtr& communicator)
     }
     cout << "ok" << endl;
 
-    string defaultHost = communicator->getProperties()->getProperty("Ice.Default.Host");
-    if(defaultHost == "127.0.0.1" || defaultHost == "::1")
+    cout << "preserved exceptions... " << flush;
+    Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("");
+    RelayPrxPtr relay = ICE_UNCHECKED_CAST(RelayPrx, adapter->addWithUUID(ICE_MAKE_SHARED(RelayI)));
+    adapter->activate();
+    test->ice_getConnection()->setAdapter(adapter);
+    try
     {
-        cout << "preserved exceptions... " << flush;
-        Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapterWithEndpoints("Relay", "default");
-        RelayPrxPtr relay = ICE_UNCHECKED_CAST(RelayPrx, adapter->addWithUUID(ICE_MAKE_SHARED(RelayI)));
-        adapter->activate();
-
-        try
-        {
-            test->relayKnownPreservedAsBase(relay);
-            test(false);
-        }
-        catch(const KnownPreservedDerived& ex)
-        {
-            test(ex.b == "base");
-            test(ex.kp == "preserved");
-            test(ex.kpd == "derived");
-        }
-        catch(const Ice::OperationNotExistException&)
-        {
-        }
-        catch(...)
-        {
-            test(false);
-        }
-
-        try
-        {
-            test->relayKnownPreservedAsKnownPreserved(relay);
-            test(false);
-        }
-        catch(const KnownPreservedDerived& ex)
-        {
-            test(ex.b == "base");
-            test(ex.kp == "preserved");
-            test(ex.kpd == "derived");
-        }
-        catch(const Ice::OperationNotExistException&)
-        {
-        }
-        catch(...)
-        {
-            test(false);
-        }
+        test->relayKnownPreservedAsBase(relay);
+        test(false);
+    }
+    catch(const KnownPreservedDerived& ex)
+    {
+        test(ex.b == "base");
+        test(ex.kp == "preserved");
+        test(ex.kpd == "derived");
+    }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
+    catch(const Ice::LocalException& ex)
+    {
+        cerr << ex << endl;
+        test(false);
+    }
+    catch(...)
+    {
+        test(false);
+    }
 
-        try
-        {
-            test->relayUnknownPreservedAsBase(relay);
-            test(false);
-        }
-        catch(const Preserved2& ex)
-        {
-            test(ex.b == "base");
-            test(ex.kp == "preserved");
-            test(ex.kpd == "derived");
-            test(ex.p1->ice_id() == PreservedClass::ice_staticId());
-            PreservedClassPtr pc = ICE_DYNAMIC_CAST(PreservedClass, ex.p1);
-            test(pc->bc == "bc");
-            test(pc->pc == "pc");
-            test(ex.p2 == ex.p1);
-        }
-        catch(const Ice::OperationNotExistException&)
-        {
-        }
-        catch(const KnownPreservedDerived& ex)
-        {
-            //
-            // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-            //
-            test(test->ice_getEncodingVersion() == Ice::Encoding_1_0);
-            test(ex.b == "base");
-            test(ex.kp == "preserved");
-            test(ex.kpd == "derived");
-        }
-        catch(...)
-        {
-            test(false);
-        }
+    try
+    {
+        test->relayKnownPreservedAsKnownPreserved(relay);
+        test(false);
+    }
+    catch(const KnownPreservedDerived& ex)
+    {
+        test(ex.b == "base");
+        test(ex.kp == "preserved");
+        test(ex.kpd == "derived");
+    }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
+    catch(...)
+    {
+        test(false);
+    }
 
-        try
-        {
-            test->relayUnknownPreservedAsKnownPreserved(relay);
-            test(false);
-        }
-        catch(const Ice::OperationNotExistException&)
-        {
-        }
-        catch(const Preserved2& ex)
-        {
-            test(ex.b == "base");
-            test(ex.kp == "preserved");
-            test(ex.kpd == "derived");
-            test(ex.p1->ice_id() == PreservedClass::ice_staticId());
-            PreservedClassPtr pc = ICE_DYNAMIC_CAST(PreservedClass, ex.p1);
-            test(pc->bc == "bc");
-            test(pc->pc == "pc");
-            test(ex.p2 == ex.p1);
-        }
-        catch(const KnownPreservedDerived& ex)
-        {
-            //
-            // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-            //
-            test(test->ice_getEncodingVersion() == Ice::Encoding_1_0);
-            test(ex.b == "base");
-            test(ex.kp == "preserved");
-            test(ex.kpd == "derived");
-        }
-        catch(...)
-        {
-            test(false);
-        }
+    try
+    {
+        test->relayUnknownPreservedAsBase(relay);
+        test(false);
+    }
+    catch(const Preserved2& ex)
+    {
+        test(ex.b == "base");
+        test(ex.kp == "preserved");
+        test(ex.kpd == "derived");
+        test(ex.p1->ice_id() == PreservedClass::ice_staticId());
+        PreservedClassPtr pc = ICE_DYNAMIC_CAST(PreservedClass, ex.p1);
+        test(pc->bc == "bc");
+        test(pc->pc == "pc");
+        test(ex.p2 == ex.p1);
+    }
+    catch(const Ice::OperationNotExistException&)
+    {
+    }
+    catch(const KnownPreservedDerived& ex)
+    {
+        //
+        // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+        //
+        test(test->ice_getEncodingVersion() == Ice::Encoding_1_0);
+        test(ex.b == "base");
+        test(ex.kp == "preserved");
+        test(ex.kpd == "derived");
+    }
+    catch(...)
+    {
+        test(false);
+    }
 
-        adapter->destroy();
-        cout << "ok" << endl;
+    try
+    {
+        test->relayUnknownPreservedAsKnownPreserved(relay);
+        test(false);
+    }
+    catch(const Ice::OperationNotExistException&)
+    {
     }
+    catch(const Preserved2& ex)
+    {
+        test(ex.b == "base");
+        test(ex.kp == "preserved");
+        test(ex.kpd == "derived");
+        test(ex.p1->ice_id() == PreservedClass::ice_staticId());
+        PreservedClassPtr pc = ICE_DYNAMIC_CAST(PreservedClass, ex.p1);
+        test(pc->bc == "bc");
+        test(pc->pc == "pc");
+        test(ex.p2 == ex.p1);
+    }
+    catch(const KnownPreservedDerived& ex)
+    {
+        //
+        // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+        //
+        test(test->ice_getEncodingVersion() == Ice::Encoding_1_0);
+        test(ex.b == "base");
+        test(ex.kp == "preserved");
+        test(ex.kpd == "derived");
+    }
+    catch(...)
+    {
+        test(false);
+    }
+
+    adapter->destroy();
+    cout << "ok" << endl;
 
     return test;
 }
diff --git a/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp b/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
index d00a1bbf83c..c2297d2a60d 100644
--- a/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
+++ b/cpp/test/Ice/slicing/exceptions/TestAMDI.cpp
@@ -292,11 +292,12 @@ TestI::knownPreservedAsKnownPreservedAsync(function<void()>, function<void(excep
 void
 TestI::relayKnownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
                                       function<void()>, function<void(exception_ptr)> error,
-                                      const ::Ice::Current&)
+                                      const ::Ice::Current& c)
 {
     try
     {
-        r->knownPreservedAsBase();
+        RelayPrxPtr p = Ice::uncheckedCast<RelayPrx>(c.con->createProxy(r->ice_getIdentity()));
+        p->knownPreservedAsBase();
         test(false);
     }
     catch(...)
@@ -308,11 +309,12 @@ TestI::relayKnownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
 void
 TestI::relayKnownPreservedAsKnownPreservedAsync(shared_ptr<RelayPrx> r,
                                                 function<void()>, function<void(exception_ptr)> error,
-                                                const ::Ice::Current&)
+                                                const ::Ice::Current& c)
 {
     try
     {
-        r->knownPreservedAsKnownPreserved();
+        RelayPrxPtr p = Ice::uncheckedCast<RelayPrx>(c.con->createProxy(r->ice_getIdentity()));
+        p->knownPreservedAsKnownPreserved();
         test(false);
     }
     catch(...)
@@ -363,11 +365,12 @@ TestI::unknownPreservedAsKnownPreservedAsync(function<void()>, function<void(exc
 void
 TestI::relayUnknownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
                                         function<void()>, function<void(exception_ptr)> error,
-                                        const ::Ice::Current&)
+                                        const ::Ice::Current& c)
 {
     try
     {
-        r->unknownPreservedAsBase();
+        RelayPrxPtr p = Ice::uncheckedCast<RelayPrx>(c.con->createProxy(r->ice_getIdentity()));
+        p->unknownPreservedAsBase();
         test(false);
     }
     catch(...)
@@ -379,11 +382,12 @@ TestI::relayUnknownPreservedAsBaseAsync(shared_ptr<RelayPrx> r,
 void
 TestI::relayUnknownPreservedAsKnownPreservedAsync(shared_ptr<RelayPrx> r,
                                                   function<void()>, function<void(exception_ptr)> error,
-                                                  const ::Ice::Current&)
+                                                  const ::Ice::Current& c)
 {
     try
     {
-        r->unknownPreservedAsKnownPreserved();
+        RelayPrxPtr p = Ice::uncheckedCast<RelayPrx>(c.con->createProxy(r->ice_getIdentity()));
+        p->unknownPreservedAsKnownPreserved();
         test(false);
     }
     catch(...)
@@ -560,11 +564,12 @@ TestI::knownPreservedAsKnownPreserved_async(const AMD_TestIntf_knownPreservedAsK
 
 void
 TestI::relayKnownPreservedAsBase_async(const AMD_TestIntf_relayKnownPreservedAsBasePtr& cb, const RelayPrx& r,
-                                       const ::Ice::Current&)
+                                       const ::Ice::Current& c)
 {
     try
     {
-        r->knownPreservedAsBase();
+        RelayPrxPtr p = RelayPrx::uncheckedCast(c.con->createProxy(r->ice_getIdentity()));
+        p->knownPreservedAsBase();
         test(false);
     }
     catch(const Ice::Exception& ex)
@@ -575,11 +580,12 @@ TestI::relayKnownPreservedAsBase_async(const AMD_TestIntf_relayKnownPreservedAsB
 
 void
 TestI::relayKnownPreservedAsKnownPreserved_async(const AMD_TestIntf_relayKnownPreservedAsKnownPreservedPtr& cb,
-                                                 const RelayPrx& r, const ::Ice::Current&)
+                                                 const RelayPrx& r, const ::Ice::Current& c)
 {
     try
     {
-        r->knownPreservedAsKnownPreserved();
+        RelayPrxPtr p = RelayPrx::uncheckedCast(c.con->createProxy(r->ice_getIdentity()));
+        p->knownPreservedAsKnownPreserved();
         test(false);
     }
     catch(const Ice::Exception& ex)
@@ -615,11 +621,12 @@ TestI::unknownPreservedAsKnownPreserved_async(const AMD_TestIntf_unknownPreserve
 
 void
 TestI::relayUnknownPreservedAsBase_async(const AMD_TestIntf_relayUnknownPreservedAsBasePtr& cb, const RelayPrx& r,
-                                         const ::Ice::Current&)
+                                         const ::Ice::Current& c)
 {
     try
     {
-        r->unknownPreservedAsBase();
+        RelayPrxPtr p = RelayPrx::uncheckedCast(c.con->createProxy(r->ice_getIdentity()));
+        p->unknownPreservedAsBase();
         test(false);
     }
     catch(const Ice::Exception& ex)
@@ -630,11 +637,12 @@ TestI::relayUnknownPreservedAsBase_async(const AMD_TestIntf_relayUnknownPreserve
 
 void
 TestI::relayUnknownPreservedAsKnownPreserved_async(const AMD_TestIntf_relayUnknownPreservedAsKnownPreservedPtr& cb,
-                                                   const RelayPrx& r, const ::Ice::Current&)
+                                                   const RelayPrx& r, const ::Ice::Current& c)
 {
     try
     {
-        r->unknownPreservedAsKnownPreserved();
+        RelayPrxPtr p = RelayPrx::uncheckedCast(c.con->createProxy(r->ice_getIdentity()));
+        p->unknownPreservedAsKnownPreserved();
         test(false);
     }
     catch(const Ice::Exception& ex)
diff --git a/cpp/test/Ice/slicing/exceptions/TestI.cpp b/cpp/test/Ice/slicing/exceptions/TestI.cpp
index 5004b7eb9f4..64773cf1d9d 100644
--- a/cpp/test/Ice/slicing/exceptions/TestI.cpp
+++ b/cpp/test/Ice/slicing/exceptions/TestI.cpp
@@ -171,16 +171,18 @@ TestI::knownPreservedAsKnownPreserved(const ::Ice::Current&)
 }
 
 void
-TestI::relayKnownPreservedAsBase(ICE_IN(RelayPrxPtr) r, const ::Ice::Current&)
+TestI::relayKnownPreservedAsBase(ICE_IN(RelayPrxPtr) r, const ::Ice::Current& c)
 {
-    r->knownPreservedAsBase();
+    RelayPrxPtr p = ICE_UNCHECKED_CAST(RelayPrx, c.con->createProxy(r->ice_getIdentity()));
+    p->knownPreservedAsBase();
     test(false);
 }
 
 void
-TestI::relayKnownPreservedAsKnownPreserved(ICE_IN(RelayPrxPtr) r, const ::Ice::Current&)
+TestI::relayKnownPreservedAsKnownPreserved(ICE_IN(RelayPrxPtr) r, const ::Ice::Current& c)
 {
-    r->knownPreservedAsKnownPreserved();
+    RelayPrxPtr p = ICE_UNCHECKED_CAST(RelayPrx, c.con->createProxy(r->ice_getIdentity()));
+    p->knownPreservedAsKnownPreserved();
     test(false);
 }
 
@@ -209,16 +211,18 @@ TestI::unknownPreservedAsKnownPreserved(const ::Ice::Current&)
 }
 
 void
-TestI::relayUnknownPreservedAsBase(ICE_IN(RelayPrxPtr) r, const ::Ice::Current&)
+TestI::relayUnknownPreservedAsBase(ICE_IN(RelayPrxPtr) r, const ::Ice::Current& c)
 {
-    r->unknownPreservedAsBase();
+    RelayPrxPtr p = ICE_UNCHECKED_CAST(RelayPrx, c.con->createProxy(r->ice_getIdentity()));
+    p->unknownPreservedAsBase();
     test(false);
 }
 
 void
-TestI::relayUnknownPreservedAsKnownPreserved(ICE_IN(RelayPrxPtr) r, const ::Ice::Current&)
+TestI::relayUnknownPreservedAsKnownPreserved(ICE_IN(RelayPrxPtr) r, const ::Ice::Current& c)
 {
-    r->unknownPreservedAsKnownPreserved();
+    RelayPrxPtr p = ICE_UNCHECKED_CAST(RelayPrx, c.con->createProxy(r->ice_getIdentity()));
+    p->unknownPreservedAsKnownPreserved();
     test(false);
 }
 
diff --git a/csharp/test/Ice/slicing/exceptions/AllTests.cs b/csharp/test/Ice/slicing/exceptions/AllTests.cs
index 46942a0b730..c579618f4e5 100644
--- a/csharp/test/Ice/slicing/exceptions/AllTests.cs
+++ b/csharp/test/Ice/slicing/exceptions/AllTests.cs
@@ -1112,126 +1112,123 @@ public class AllTests : TestCommon.AllTests
         }
         WriteLine("ok");
 
-        string defaultHost = communicator.getProperties().getProperty("Ice.Default.Host");
-        if(defaultHost.Equals("127.0.0.1") || defaultHost.Equals("::1"))
+        Write("preserved exceptions... ");
+        Flush();
         {
-            Write("preserved exceptions... ");
-            Flush();
-            {
-                Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints("Relay", "default");
-                RelayPrx relay = RelayPrxHelper.uncheckedCast(adapter.addWithUUID(new RelayI()));
-                adapter.activate();
-
-                try
-                {
-                    testPrx.relayKnownPreservedAsBase(relay);
-                    test(false);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    test(ex.b.Equals("base"));
-                    test(ex.kp.Equals("preserved"));
-                    test(ex.kpd.Equals("derived"));
-                }
-                catch(Ice.OperationNotExistException)
-                {
-                }
-                catch(Exception)
-                {
-                    test(false);
-                }
+            Ice.ObjectAdapter adapter = communicator.createObjectAdapter("");
+            RelayPrx relay = RelayPrxHelper.uncheckedCast(adapter.addWithUUID(new RelayI()));
+            adapter.activate();
+            testPrx.ice_getConnection().setAdapter(adapter);
 
-                try
-                {
-                    testPrx.relayKnownPreservedAsKnownPreserved(relay);
-                    test(false);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    test(ex.b.Equals("base"));
-                    test(ex.kp.Equals("preserved"));
-                    test(ex.kpd.Equals("derived"));
-                }
-                catch(Ice.OperationNotExistException)
-                {
-                }
-                catch(Exception)
-                {
-                    test(false);
-                }
+            try
+            {
+                testPrx.relayKnownPreservedAsBase(relay);
+                test(false);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                test(ex.b.Equals("base"));
+                test(ex.kp.Equals("preserved"));
+                test(ex.kpd.Equals("derived"));
+            }
+            catch(Ice.OperationNotExistException)
+            {
+            }
+            catch(Exception)
+            {
+                test(false);
+            }
 
-                try
-                {
-                    testPrx.relayUnknownPreservedAsBase(relay);
-                    test(false);
-                }
-                catch(Preserved2 ex)
-                {
-                    test(ex.b.Equals("base"));
-                    test(ex.kp.Equals("preserved"));
-                    test(ex.kpd.Equals("derived"));
-                    test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId()));
-                    PreservedClass pc = ex.p1 as PreservedClass;
-                    test(pc.bc.Equals("bc"));
-                    test(pc.pc.Equals("pc"));
-                    test(ex.p2 == ex.p1);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    //
-                    // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-                    //
-                    test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0));
-                    test(ex.b.Equals("base"));
-                    test(ex.kp.Equals("preserved"));
-                    test(ex.kpd.Equals("derived"));
-                }
-                catch(Ice.OperationNotExistException)
-                {
-                }
-                catch(Exception)
-                {
-                    test(false);
-                }
+            try
+            {
+                testPrx.relayKnownPreservedAsKnownPreserved(relay);
+                test(false);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                test(ex.b.Equals("base"));
+                test(ex.kp.Equals("preserved"));
+                test(ex.kpd.Equals("derived"));
+            }
+            catch(Ice.OperationNotExistException)
+            {
+            }
+            catch(Exception)
+            {
+                test(false);
+            }
 
-                try
-                {
-                    testPrx.relayUnknownPreservedAsKnownPreserved(relay);
-                    test(false);
-                }
-                catch(Preserved2 ex)
-                {
-                    test(ex.b.Equals("base"));
-                    test(ex.kp.Equals("preserved"));
-                    test(ex.kpd.Equals("derived"));
-                    test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId()));
-                    PreservedClass pc = ex.p1 as PreservedClass;
-                    test(pc.bc.Equals("bc"));
-                    test(pc.pc.Equals("pc"));
-                    test(ex.p2 == ex.p1);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    //
-                    // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-                    //
-                    test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0));
-                    test(ex.b.Equals("base"));
-                    test(ex.kp.Equals("preserved"));
-                    test(ex.kpd.Equals("derived"));
-                }
-                catch(Ice.OperationNotExistException)
-                {
-                }
-                catch(Exception)
-                {
-                    test(false);
-                }
+            try
+            {
+                testPrx.relayUnknownPreservedAsBase(relay);
+                test(false);
+            }
+            catch(Preserved2 ex)
+            {
+                test(ex.b.Equals("base"));
+                test(ex.kp.Equals("preserved"));
+                test(ex.kpd.Equals("derived"));
+                test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId()));
+                PreservedClass pc = ex.p1 as PreservedClass;
+                test(pc.bc.Equals("bc"));
+                test(pc.pc.Equals("pc"));
+                test(ex.p2 == ex.p1);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                //
+                // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+                //
+                test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0));
+                test(ex.b.Equals("base"));
+                test(ex.kp.Equals("preserved"));
+                test(ex.kpd.Equals("derived"));
+            }
+            catch(Ice.OperationNotExistException)
+            {
+            }
+            catch(Exception)
+            {
+                test(false);
+            }
 
-                adapter.destroy();
+            try
+            {
+                testPrx.relayUnknownPreservedAsKnownPreserved(relay);
+                test(false);
+            }
+            catch(Preserved2 ex)
+            {
+                test(ex.b.Equals("base"));
+                test(ex.kp.Equals("preserved"));
+                test(ex.kpd.Equals("derived"));
+                test(ex.p1.ice_id().Equals(PreservedClass.ice_staticId()));
+                PreservedClass pc = ex.p1 as PreservedClass;
+                test(pc.bc.Equals("bc"));
+                test(pc.pc.Equals("pc"));
+                test(ex.p2 == ex.p1);
             }
-            WriteLine("ok");
+            catch(KnownPreservedDerived ex)
+            {
+                //
+                // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+                //
+                test(testPrx.ice_getEncodingVersion().Equals(Ice.Util.Encoding_1_0));
+                test(ex.b.Equals("base"));
+                test(ex.kp.Equals("preserved"));
+                test(ex.kpd.Equals("derived"));
+            }
+            catch(Ice.OperationNotExistException)
+            {
+            }
+            catch(Exception)
+            {
+                test(false);
+            }
+
+            adapter.destroy();
         }
+        WriteLine("ok");
 
         return testPrx;
     }
diff --git a/csharp/test/Ice/slicing/exceptions/TestAMDI.cs b/csharp/test/Ice/slicing/exceptions/TestAMDI.cs
index 60ce36cbd85..2713b4a10c8 100644
--- a/csharp/test/Ice/slicing/exceptions/TestAMDI.cs
+++ b/csharp/test/Ice/slicing/exceptions/TestAMDI.cs
@@ -122,7 +122,8 @@ public sealed class TestI : TestIntfDisp_
     public override Task
     relayKnownPreservedAsBaseAsync(RelayPrx r, Ice.Current current)
     {
-        r.knownPreservedAsBase();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsBase();
         test(false);
         return null;
     }
@@ -130,7 +131,8 @@ public sealed class TestI : TestIntfDisp_
     public override Task
     relayKnownPreservedAsKnownPreservedAsync(RelayPrx r, Ice.Current current)
     {
-        r.knownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsKnownPreserved();
         test(false);
         return null;
     }
@@ -161,7 +163,8 @@ public sealed class TestI : TestIntfDisp_
     public override Task
     relayUnknownPreservedAsBaseAsync(RelayPrx r, Ice.Current current)
     {
-        r.unknownPreservedAsBase();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsBase();
         test(false);
         return null;
     }
@@ -169,7 +172,8 @@ public sealed class TestI : TestIntfDisp_
     public override Task
     relayUnknownPreservedAsKnownPreservedAsync(RelayPrx r, Ice.Current current)
     {
-        r.unknownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsKnownPreserved();
         test(false);
         return null;
     }
diff --git a/csharp/test/Ice/slicing/exceptions/TestI.cs b/csharp/test/Ice/slicing/exceptions/TestI.cs
index 60655af4e2a..6896f7a7618 100644
--- a/csharp/test/Ice/slicing/exceptions/TestI.cs
+++ b/csharp/test/Ice/slicing/exceptions/TestI.cs
@@ -162,13 +162,15 @@ public sealed class TestI : TestIntfDisp_
 
     public override void relayKnownPreservedAsBase(RelayPrx r, Ice.Current current)
     {
-        r.knownPreservedAsBase();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsBase();
         test(false);
     }
 
     public override void relayKnownPreservedAsKnownPreserved(RelayPrx r, Ice.Current current)
     {
-        r.knownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsKnownPreserved();
         test(false);
     }
 
@@ -196,13 +198,15 @@ public sealed class TestI : TestIntfDisp_
 
     public override void relayUnknownPreservedAsBase(RelayPrx r, Ice.Current current)
     {
-        r.unknownPreservedAsBase();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsBase();
         test(false);
     }
 
     public override void relayUnknownPreservedAsKnownPreserved(RelayPrx r, Ice.Current current)
     {
-        r.unknownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsKnownPreserved();
         test(false);
     }
 }
diff --git a/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java b/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java
index 954a4984cd8..b8539082616 100644
--- a/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java
+++ b/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java
@@ -221,7 +221,8 @@ public final class AMDTestI extends _TestIntfDisp
     {
         try
         {
-            r.knownPreservedAsBase();
+            RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.knownPreservedAsBase();
             test(false);
         }
         catch(Ice.UserException ex)
@@ -241,7 +242,8 @@ public final class AMDTestI extends _TestIntfDisp
     {
         try
         {
-            r.knownPreservedAsKnownPreserved();
+            RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.knownPreservedAsKnownPreserved();
             test(false);
         }
         catch(Ice.UserException ex)
@@ -286,7 +288,8 @@ public final class AMDTestI extends _TestIntfDisp
     {
         try
         {
-            r.unknownPreservedAsBase();
+            RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.unknownPreservedAsBase();
             test(false);
         }
         catch(Ice.UserException ex)
@@ -306,7 +309,8 @@ public final class AMDTestI extends _TestIntfDisp
     {
         try
         {
-            r.unknownPreservedAsKnownPreserved();
+            RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.unknownPreservedAsKnownPreserved();
             test(false);
         }
         catch(Ice.UserException ex)
diff --git a/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java b/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java
index eb398a31f38..af723f0b9f7 100644
--- a/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java
+++ b/java-compat/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java
@@ -1159,126 +1159,123 @@ public class AllTests
         }
         out.println("ok");
 
-        final String defaultHost = communicator.getProperties().getProperty("Ice.Default.Host");
-        if(defaultHost.equals("127.0.0.1") || defaultHost.equals("::1"))
+        out.print("preserved exceptions... ");
+        out.flush();
         {
-            out.print("preserved exceptions... ");
-            out.flush();
-            {
-                Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints("Relay", "default");
-                RelayPrx relay = RelayPrxHelper.uncheckedCast(adapter.addWithUUID(new RelayI()));
-                adapter.activate();
-
-                try
-                {
-                    test.relayKnownPreservedAsBase(relay);
-                    test(false);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            Ice.ObjectAdapter adapter = communicator.createObjectAdapter("");
+            RelayPrx relay = RelayPrxHelper.uncheckedCast(adapter.addWithUUID(new RelayI()));
+            adapter.activate();
+            test.ice_getConnection().setAdapter(adapter);
 
-                try
-                {
-                    test.relayKnownPreservedAsKnownPreserved(relay);
-                    test(false);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            try
+            {
+                test.relayKnownPreservedAsBase(relay);
+                test(false);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(Ice.OperationNotExistException ex)
+            {
+            }
+            catch(Exception ex)
+            {
+                test(false);
+            }
 
-                try
-                {
-                    test.relayUnknownPreservedAsBase(relay);
-                    test(false);
-                }
-                catch(Preserved2 ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                    test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
-                    PreservedClass pc = (PreservedClass)ex.p1;
-                    test(pc.bc.equals("bc"));
-                    test(pc.pc.equals("pc"));
-                    test(ex.p2 == ex.p1);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    //
-                    // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-                    //
-                    test(test.ice_getEncodingVersion().equals(Ice.Util.Encoding_1_0));
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            try
+            {
+                test.relayKnownPreservedAsKnownPreserved(relay);
+                test(false);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(Ice.OperationNotExistException ex)
+            {
+            }
+            catch(Exception ex)
+            {
+                test(false);
+            }
 
-                try
-                {
-                    test.relayUnknownPreservedAsKnownPreserved(relay);
-                    test(false);
-                }
-                catch(Preserved2 ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                    test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
-                    PreservedClass pc = (PreservedClass)ex.p1;
-                    test(pc.bc.equals("bc"));
-                    test(pc.pc.equals("pc"));
-                    test(ex.p2 == ex.p1);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    //
-                    // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-                    //
-                    test(test.ice_getEncodingVersion().equals(Ice.Util.Encoding_1_0));
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            try
+            {
+                test.relayUnknownPreservedAsBase(relay);
+                test(false);
+            }
+            catch(Preserved2 ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+                test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
+                PreservedClass pc = (PreservedClass)ex.p1;
+                test(pc.bc.equals("bc"));
+                test(pc.pc.equals("pc"));
+                test(ex.p2 == ex.p1);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                //
+                // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+                //
+                test(test.ice_getEncodingVersion().equals(Ice.Util.Encoding_1_0));
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(Ice.OperationNotExistException ex)
+            {
+            }
+            catch(Exception ex)
+            {
+                test(false);
+            }
 
-                adapter.destroy();
+            try
+            {
+                test.relayUnknownPreservedAsKnownPreserved(relay);
+                test(false);
+            }
+            catch(Preserved2 ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+                test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
+                PreservedClass pc = (PreservedClass)ex.p1;
+                test(pc.bc.equals("bc"));
+                test(pc.pc.equals("pc"));
+                test(ex.p2 == ex.p1);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                //
+                // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+                //
+                test(test.ice_getEncodingVersion().equals(Ice.Util.Encoding_1_0));
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(Ice.OperationNotExistException ex)
+            {
             }
-            out.println("ok");
+            catch(Exception ex)
+            {
+                test(false);
+            }
+
+            adapter.destroy();
         }
+        out.println("ok");
 
         return test;
     }
diff --git a/java-compat/test/src/main/java/test/Ice/slicing/exceptions/TestI.java b/java-compat/test/src/main/java/test/Ice/slicing/exceptions/TestI.java
index 7bd9389d616..621e3a86917 100644
--- a/java-compat/test/src/main/java/test/Ice/slicing/exceptions/TestI.java
+++ b/java-compat/test/src/main/java/test/Ice/slicing/exceptions/TestI.java
@@ -218,7 +218,8 @@ public final class TestI extends _TestIntfDisp
     relayKnownPreservedAsBase(RelayPrx r, Ice.Current current)
         throws Base
     {
-        r.knownPreservedAsBase();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsBase();
         test(false);
     }
 
@@ -227,7 +228,8 @@ public final class TestI extends _TestIntfDisp
     relayKnownPreservedAsKnownPreserved(RelayPrx r, Ice.Current current)
         throws KnownPreserved
     {
-        r.knownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsKnownPreserved();
         test(false);
     }
 
@@ -264,7 +266,8 @@ public final class TestI extends _TestIntfDisp
     relayUnknownPreservedAsBase(RelayPrx r, Ice.Current current)
         throws Base
     {
-        r.unknownPreservedAsBase();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsBase();
         test(false);
     }
 
@@ -273,7 +276,8 @@ public final class TestI extends _TestIntfDisp
     relayUnknownPreservedAsKnownPreserved(RelayPrx r, Ice.Current current)
         throws KnownPreserved
     {
-        r.unknownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrxHelper.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsKnownPreserved();
         test(false);
     }
 }
diff --git a/java/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java b/java/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java
index 2039ac2de3c..ecf84786c3d 100644
--- a/java/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java
+++ b/java/test/src/main/java/test/Ice/slicing/exceptions/AMDTestI.java
@@ -234,7 +234,8 @@ public final class AMDTestI implements TestIntf
     {
         try
         {
-            r.knownPreservedAsBase();
+            RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.knownPreservedAsBase();
             test(false);
             return null;
         }
@@ -257,7 +258,8 @@ public final class AMDTestI implements TestIntf
     {
         try
         {
-            r.knownPreservedAsKnownPreserved();
+            RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.knownPreservedAsKnownPreserved();
             test(false);
             return null;
         }
@@ -308,7 +310,8 @@ public final class AMDTestI implements TestIntf
     {
         try
         {
-            r.unknownPreservedAsBase();
+            RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.unknownPreservedAsBase();
             test(false);
             return null;
         }
@@ -331,7 +334,8 @@ public final class AMDTestI implements TestIntf
     {
         try
         {
-            r.unknownPreservedAsKnownPreserved();
+            RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+            p.unknownPreservedAsKnownPreserved();
             test(false);
             return null;
         }
diff --git a/java/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java b/java/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java
index 57e8565ce94..8445d06ae74 100644
--- a/java/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java
+++ b/java/test/src/main/java/test/Ice/slicing/exceptions/AllTests.java
@@ -649,126 +649,123 @@ public class AllTests
         }
         out.println("ok");
 
-        final String defaultHost = communicator.getProperties().getProperty("Ice.Default.Host");
-        if(defaultHost.equals("127.0.0.1") || defaultHost.equals("::1"))
+        out.print("preserved exceptions... ");
+        out.flush();
         {
-            out.print("preserved exceptions... ");
-            out.flush();
-            {
-                com.zeroc.Ice.ObjectAdapter adapter = communicator.createObjectAdapterWithEndpoints("Relay", "default");
-                RelayPrx relay = RelayPrx.uncheckedCast(adapter.addWithUUID(new RelayI()));
-                adapter.activate();
-
-                try
-                {
-                    test.relayKnownPreservedAsBase(relay);
-                    test(false);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(com.zeroc.Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            com.zeroc.Ice.ObjectAdapter adapter = communicator.createObjectAdapter("");
+            RelayPrx relay = RelayPrx.uncheckedCast(adapter.addWithUUID(new RelayI()));
+            adapter.activate();
+            test.ice_getConnection().setAdapter(adapter);
 
-                try
-                {
-                    test.relayKnownPreservedAsKnownPreserved(relay);
-                    test(false);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(com.zeroc.Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            try
+            {
+                test.relayKnownPreservedAsBase(relay);
+                test(false);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(com.zeroc.Ice.OperationNotExistException ex)
+            {
+            }
+            catch(Exception ex)
+            {
+                test(false);
+            }
 
-                try
-                {
-                    test.relayUnknownPreservedAsBase(relay);
-                    test(false);
-                }
-                catch(Preserved2 ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                    test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
-                    PreservedClass pc = (PreservedClass)ex.p1;
-                    test(pc.bc.equals("bc"));
-                    test(pc.pc.equals("pc"));
-                    test(ex.p2 == ex.p1);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    //
-                    // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-                    //
-                    test(test.ice_getEncodingVersion().equals(com.zeroc.Ice.Util.Encoding_1_0));
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(com.zeroc.Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            try
+            {
+                test.relayKnownPreservedAsKnownPreserved(relay);
+                test(false);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(com.zeroc.Ice.OperationNotExistException ex)
+            {
+            }
+            catch(Exception ex)
+            {
+                test(false);
+            }
 
-                try
-                {
-                    test.relayUnknownPreservedAsKnownPreserved(relay);
-                    test(false);
-                }
-                catch(Preserved2 ex)
-                {
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                    test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
-                    PreservedClass pc = (PreservedClass)ex.p1;
-                    test(pc.bc.equals("bc"));
-                    test(pc.pc.equals("pc"));
-                    test(ex.p2 == ex.p1);
-                }
-                catch(KnownPreservedDerived ex)
-                {
-                    //
-                    // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-                    //
-                    test(test.ice_getEncodingVersion().equals(com.zeroc.Ice.Util.Encoding_1_0));
-                    test(ex.b.equals("base"));
-                    test(ex.kp.equals("preserved"));
-                    test(ex.kpd.equals("derived"));
-                }
-                catch(com.zeroc.Ice.OperationNotExistException ex)
-                {
-                }
-                catch(Exception ex)
-                {
-                    test(false);
-                }
+            try
+            {
+                test.relayUnknownPreservedAsBase(relay);
+                test(false);
+            }
+            catch(Preserved2 ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+                test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
+                PreservedClass pc = (PreservedClass)ex.p1;
+                test(pc.bc.equals("bc"));
+                test(pc.pc.equals("pc"));
+                test(ex.p2 == ex.p1);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                //
+                // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+                //
+                test(test.ice_getEncodingVersion().equals(com.zeroc.Ice.Util.Encoding_1_0));
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(com.zeroc.Ice.OperationNotExistException ex)
+            {
+            }
+            catch(Exception ex)
+            {
+                test(false);
+            }
 
-                adapter.destroy();
+            try
+            {
+                test.relayUnknownPreservedAsKnownPreserved(relay);
+                test(false);
+            }
+            catch(Preserved2 ex)
+            {
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+                test(ex.p1.ice_id().equals(PreservedClass.ice_staticId()));
+                PreservedClass pc = (PreservedClass)ex.p1;
+                test(pc.bc.equals("bc"));
+                test(pc.pc.equals("pc"));
+                test(ex.p2 == ex.p1);
+            }
+            catch(KnownPreservedDerived ex)
+            {
+                //
+                // For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+                //
+                test(test.ice_getEncodingVersion().equals(com.zeroc.Ice.Util.Encoding_1_0));
+                test(ex.b.equals("base"));
+                test(ex.kp.equals("preserved"));
+                test(ex.kpd.equals("derived"));
+            }
+            catch(com.zeroc.Ice.OperationNotExistException ex)
+            {
             }
-            out.println("ok");
+            catch(Exception ex)
+            {
+                test(false);
+            }
+
+            adapter.destroy();
         }
+        out.println("ok");
 
         return test;
     }
diff --git a/java/test/src/main/java/test/Ice/slicing/exceptions/TestI.java b/java/test/src/main/java/test/Ice/slicing/exceptions/TestI.java
index b4a320ad3b4..9276497cd89 100644
--- a/java/test/src/main/java/test/Ice/slicing/exceptions/TestI.java
+++ b/java/test/src/main/java/test/Ice/slicing/exceptions/TestI.java
@@ -200,7 +200,8 @@ public final class TestI implements TestIntf
     public void relayKnownPreservedAsBase(RelayPrx r, com.zeroc.Ice.Current current)
         throws Base
     {
-        r.knownPreservedAsBase();
+        RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsBase();
         test(false);
     }
 
@@ -208,7 +209,8 @@ public final class TestI implements TestIntf
     public void relayKnownPreservedAsKnownPreserved(RelayPrx r, com.zeroc.Ice.Current current)
         throws KnownPreserved
     {
-        r.knownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.knownPreservedAsKnownPreserved();
         test(false);
     }
 
@@ -242,7 +244,8 @@ public final class TestI implements TestIntf
     public void relayUnknownPreservedAsBase(RelayPrx r, com.zeroc.Ice.Current current)
         throws Base
     {
-        r.unknownPreservedAsBase();
+        RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsBase();
         test(false);
     }
 
@@ -250,7 +253,8 @@ public final class TestI implements TestIntf
     public void relayUnknownPreservedAsKnownPreserved(RelayPrx r, com.zeroc.Ice.Current current)
         throws KnownPreserved
     {
-        r.unknownPreservedAsKnownPreserved();
+        RelayPrx p = RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()));
+        p.unknownPreservedAsKnownPreserved();
         test(false);
     }
 }
diff --git a/objective-c/test/Ice/slicing/exceptions/AllTests.m b/objective-c/test/Ice/slicing/exceptions/AllTests.m
index 719a2d0b12d..41af9beedef 100644
--- a/objective-c/test/Ice/slicing/exceptions/AllTests.m
+++ b/objective-c/test/Ice/slicing/exceptions/AllTests.m
@@ -685,11 +685,11 @@ slicingExceptionsAllTests(id<ICECommunicator> communicator)
 
     tprintf("preserved exceptions... ");
     {
-        id<ICEObjectAdapter> adapter = [communicator createObjectAdapterWithEndpoints:@"Relay" endpoints:@"default"];
+        id<ICEObjectAdapter> adapter = [communicator createObjectAdapter:@""];
         TestSlicingExceptionsClientRelayPrx* relay =
             [TestSlicingExceptionsClientRelayPrx uncheckedCast:[adapter addWithUUID:[RelayI relay]]];
         [adapter activate];
-
+        [[test ice_getConnection] setAdapter:adapter];
         @try
         {
             [test relayKnownPreservedAsBase:relay];
diff --git a/objective-c/test/Ice/slicing/exceptions/TestI.m b/objective-c/test/Ice/slicing/exceptions/TestI.m
index c77d4a7c1bd..d9587ee8e8d 100644
--- a/objective-c/test/Ice/slicing/exceptions/TestI.m
+++ b/objective-c/test/Ice/slicing/exceptions/TestI.m
@@ -104,13 +104,17 @@
 
 -(void) relayKnownPreservedAsBase:(TestSlicingExceptionsServerRelayPrx*)relay current:(ICECurrent*)current
 {
-    [relay knownPreservedAsBase];
+    TestSlicingExceptionsServerRelayPrx* p =
+        [TestSlicingExceptionsServerRelayPrx uncheckedCast:[current.con createProxy:[relay ice_getIdentity]]];
+    [p knownPreservedAsBase];
     test(NO);
 }
 
 -(void) relayKnownPreservedAsKnownPreserved:(TestSlicingExceptionsServerRelayPrx*)relay current:(ICECurrent*)current
 {
-    [relay knownPreservedAsKnownPreserved];
+    TestSlicingExceptionsServerRelayPrx* p =
+        [TestSlicingExceptionsServerRelayPrx uncheckedCast:[current.con createProxy:[relay ice_getIdentity]]];
+    [p knownPreservedAsKnownPreserved];
     test(NO);
 }
 
@@ -138,13 +142,17 @@
 
 -(void) relayUnknownPreservedAsBase:(TestSlicingExceptionsServerRelayPrx*)relay current:(ICECurrent*)current
 {
-    [relay unknownPreservedAsBase];
+    TestSlicingExceptionsServerRelayPrx* p =
+        [TestSlicingExceptionsServerRelayPrx uncheckedCast:[current.con createProxy:[relay ice_getIdentity]]];
+    [p unknownPreservedAsBase];
     test(NO);
 }
 
 -(void) relayUnknownPreservedAsKnownPreserved:(TestSlicingExceptionsServerRelayPrx*)relay current:(ICECurrent*)current
 {
-    [relay unknownPreservedAsKnownPreserved];
+    TestSlicingExceptionsServerRelayPrx* p =
+        [TestSlicingExceptionsServerRelayPrx uncheckedCast:[current.con createProxy:[relay ice_getIdentity]]];
+    [p unknownPreservedAsKnownPreserved];
     test(NO);
 }
 
diff --git a/python/test/Ice/slicing/exceptions/AllTests.py b/python/test/Ice/slicing/exceptions/AllTests.py
index 92602a5ce80..e80429d8748 100644
--- a/python/test/Ice/slicing/exceptions/AllTests.py
+++ b/python/test/Ice/slicing/exceptions/AllTests.py
@@ -508,91 +508,90 @@ def allTests(communicator):
         test(False)
     print("ok")
 
-    defaultHost = communicator.getProperties().getProperty("Ice.Default.Host")
-    if defaultHost == "127.0.0.1" or defaultHost == "::1":
-        sys.stdout.write("preserved exceptions... ")
-        sys.stdout.flush()
-        adapter = communicator.createObjectAdapterWithEndpoints("Relay", "default")
-        relay = Test.RelayPrx.uncheckedCast(adapter.addWithUUID(RelayI()))
-        adapter.activate()
+    sys.stdout.write("preserved exceptions... ")
+    sys.stdout.flush()
+    adapter = communicator.createObjectAdapter("")
+    relay = Test.RelayPrx.uncheckedCast(adapter.addWithUUID(RelayI()))
+    adapter.activate()
+    t.ice_getConnection().setAdapter(adapter)
 
-        try:
-            t.relayKnownPreservedAsBase(relay)
-            test(False)
-        except Test.KnownPreservedDerived as ex:
-            test(ex.b == "base")
-            test(ex.kp == "preserved")
-            test(ex.kpd == "derived")
-        except Ice.OperationNotExistException:
-            pass
-        except:
-            test(False)
+    try:
+        t.relayKnownPreservedAsBase(relay)
+        test(False)
+    except Test.KnownPreservedDerived as ex:
+        test(ex.b == "base")
+        test(ex.kp == "preserved")
+        test(ex.kpd == "derived")
+    except Ice.OperationNotExistException:
+        pass
+    except:
+        test(False)
 
-        try:
-            t.relayKnownPreservedAsKnownPreserved(relay)
-            test(False)
-        except Test.KnownPreservedDerived as ex:
-            test(ex.b == "base")
-            test(ex.kp == "preserved")
-            test(ex.kpd == "derived")
-        except Ice.OperationNotExistException:
-            pass
-        except:
-            test(False)
+    try:
+        t.relayKnownPreservedAsKnownPreserved(relay)
+        test(False)
+    except Test.KnownPreservedDerived as ex:
+        test(ex.b == "base")
+        test(ex.kp == "preserved")
+        test(ex.kpd == "derived")
+    except Ice.OperationNotExistException:
+        pass
+    except:
+        test(False)
 
-        try:
-            t.relayUnknownPreservedAsBase(relay)
-            test(False)
-        except Test.Preserved2 as ex:
-            test(ex.b == "base")
-            test(ex.kp == "preserved")
-            test(ex.kpd == "derived")
-            test(ex.p1.ice_id() == Test.PreservedClass.ice_staticId())
-            pc = ex.p1
-            test(isinstance(pc, Test.PreservedClass))
-            test(pc.bc == "bc")
-            test(pc.pc == "pc")
-            test(ex.p2 == ex.p1)
-        except Test.KnownPreservedDerived as ex:
-            #
-            # For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-            #
-            test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
-            test(ex.b == "base")
-            test(ex.kp == "preserved")
-            test(ex.kpd == "derived")
-        except Ice.OperationNotExistException:
-            pass
-        except:
-            test(False)
+    try:
+        t.relayUnknownPreservedAsBase(relay)
+        test(False)
+    except Test.Preserved2 as ex:
+        test(ex.b == "base")
+        test(ex.kp == "preserved")
+        test(ex.kpd == "derived")
+        test(ex.p1.ice_id() == Test.PreservedClass.ice_staticId())
+        pc = ex.p1
+        test(isinstance(pc, Test.PreservedClass))
+        test(pc.bc == "bc")
+        test(pc.pc == "pc")
+        test(ex.p2 == ex.p1)
+    except Test.KnownPreservedDerived as ex:
+        #
+        # For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+        #
+        test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
+        test(ex.b == "base")
+        test(ex.kp == "preserved")
+        test(ex.kpd == "derived")
+    except Ice.OperationNotExistException:
+        pass
+    except:
+        test(False)
 
-        try:
-            t.relayUnknownPreservedAsKnownPreserved(relay)
-            test(False)
-        except Test.Preserved2 as ex:
-            test(ex.b == "base")
-            test(ex.kp == "preserved")
-            test(ex.kpd == "derived")
-            test(ex.p1.ice_id() == Test.PreservedClass.ice_staticId())
-            pc = ex.p1
-            test(isinstance(pc, Test.PreservedClass))
-            test(pc.bc == "bc")
-            test(pc.pc == "pc")
-            test(ex.p2 == ex.p1)
-        except Test.KnownPreservedDerived as ex:
-            #
-            # For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
-            #
-            test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
-            test(ex.b == "base")
-            test(ex.kp == "preserved")
-            test(ex.kpd == "derived")
-        except Ice.OperationNotExistException:
-            pass
-        except:
-            test(False)
+    try:
+        t.relayUnknownPreservedAsKnownPreserved(relay)
+        test(False)
+    except Test.Preserved2 as ex:
+        test(ex.b == "base")
+        test(ex.kp == "preserved")
+        test(ex.kpd == "derived")
+        test(ex.p1.ice_id() == Test.PreservedClass.ice_staticId())
+        pc = ex.p1
+        test(isinstance(pc, Test.PreservedClass))
+        test(pc.bc == "bc")
+        test(pc.pc == "pc")
+        test(ex.p2 == ex.p1)
+    except Test.KnownPreservedDerived as ex:
+        #
+        # For the 1.0 encoding, the unknown exception is sliced to KnownPreserved.
+        #
+        test(t.ice_getEncodingVersion() == Ice.Encoding_1_0)
+        test(ex.b == "base")
+        test(ex.kp == "preserved")
+        test(ex.kpd == "derived")
+    except Ice.OperationNotExistException:
+        pass
+    except:
+        test(False)
 
-        adapter.destroy()
-        print("ok")
+    adapter.destroy()
+    print("ok")
 
     return t
diff --git a/python/test/Ice/slicing/exceptions/Server.py b/python/test/Ice/slicing/exceptions/Server.py
index 44a58914a5f..0a52aa525ab 100755
--- a/python/test/Ice/slicing/exceptions/Server.py
+++ b/python/test/Ice/slicing/exceptions/Server.py
@@ -121,11 +121,13 @@ class TestI(Test.TestIntf):
         ex.kpd = "derived"
         raise ex
 
-    def relayKnownPreservedAsBase(self, r, current=None):
-        r.knownPreservedAsBase()
+    def relayKnownPreservedAsBase(self, r, current):
+        p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+        p.knownPreservedAsBase()
 
-    def relayKnownPreservedAsKnownPreserved(self, r, current=None):
-        r.knownPreservedAsKnownPreserved()
+    def relayKnownPreservedAsKnownPreserved(self, r, current):
+        p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+        p.knownPreservedAsKnownPreserved()
 
     def unknownPreservedAsBase(self, current=None):
         ex = Test.SPreserved2()
@@ -145,11 +147,13 @@ class TestI(Test.TestIntf):
         ex.p2 = ex.p1
         raise ex
 
-    def relayUnknownPreservedAsBase(self, r, current=None):
-        r.unknownPreservedAsBase()
+    def relayUnknownPreservedAsBase(self, r, current):
+        p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+        p.unknownPreservedAsBase()
 
-    def relayUnknownPreservedAsKnownPreserved(self, r, current=None):
-        r.unknownPreservedAsKnownPreserved()
+    def relayUnknownPreservedAsKnownPreserved(self, r, current):
+        p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+        p.unknownPreservedAsKnownPreserved()
 
 def run(args, communicator):
     properties = communicator.getProperties()
diff --git a/python/test/Ice/slicing/exceptions/ServerAMD.py b/python/test/Ice/slicing/exceptions/ServerAMD.py
index 8c0513cc4e8..9f04f121ad0 100755
--- a/python/test/Ice/slicing/exceptions/ServerAMD.py
+++ b/python/test/Ice/slicing/exceptions/ServerAMD.py
@@ -154,19 +154,21 @@ class TestI(Test.TestIntf):
         f.set_exception(ex)
         return f
 
-    def relayKnownPreservedAsBase(self, r, current=None):
+    def relayKnownPreservedAsBase(self, r, current):
         f = Ice.Future()
         try:
-            r.knownPreservedAsBase()
+            p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+            p.knownPreservedAsBase()
             test(False)
         except Ice.Exception as ex:
             f.set_exception(ex)
         return f
 
-    def relayKnownPreservedAsKnownPreserved(self, r, current=None):
+    def relayKnownPreservedAsKnownPreserved(self, r, current):
         f = Ice.Future()
         try:
-            r.knownPreservedAsKnownPreserved()
+            p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+            p.knownPreservedAsKnownPreserved()
             test(False)
         except Ice.Exception as ex:
             f.set_exception(ex)
@@ -194,19 +196,21 @@ class TestI(Test.TestIntf):
         f.set_exception(ex)
         return f
 
-    def relayUnknownPreservedAsBase(self, r, current=None):
+    def relayUnknownPreservedAsBase(self, r, current):
         f = Ice.Future()
         try:
-            r.unknownPreservedAsBase()
+            p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+            p.unknownPreservedAsBase()
             test(False)
         except Ice.Exception as ex:
             f.set_exception(ex)
         return f
 
-    def relayUnknownPreservedAsKnownPreserved(self, r, current=None):
+    def relayUnknownPreservedAsKnownPreserved(self, r, current):
         f = Ice.Future()
         try:
-            r.unknownPreservedAsKnownPreserved()
+            p = Test.RelayPrx.uncheckedCast(current.con.createProxy(r.ice_getIdentity()))
+            p.unknownPreservedAsKnownPreserved()
             test(False)
         except Ice.Exception as ex:
             f.set_exception(ex)