1 files changed, 390 insertions, 0 deletions
diff --git a/cpp/test/Ice/exceptions/TestAMDI.cpp b/cpp/test/Ice/exceptions/TestAMDI.cpp
index 6c9a884cab9..bcc6abf49b8 100644
--- a/cpp/test/Ice/exceptions/TestAMDI.cpp
+++ b/cpp/test/Ice/exceptions/TestAMDI.cpp
@@ -28,6 +28,395 @@ ThrowerI::ThrowerI()
 {
 }
 
+#ifdef ICE_CPP11_MAPPING
+void
+ThrowerI::shutdownAsync(function<void()> response,
+                        function<void(exception_ptr)>,
+                        const Ice::Current& current)
+{
+    current.adapter->getCommunicator()->shutdown();
+    response();
+}
+
+void
+ThrowerI::supportsUndeclaredExceptionsAsync(function<void(bool)> response,
+                                            function<void(exception_ptr)>,
+                                            const Ice::Current&)
+{
+    response(true);
+}
+
+void
+ThrowerI::supportsAssertExceptionAsync(function<void(bool)> response,
+                                       function<void(exception_ptr)>,
+                                       const Ice::Current&)
+{
+    response(false);
+}
+
+void
+ThrowerI::throwAasAAsync(int a,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
+                         const Ice::Current&)
+{
+    try
+    {
+        A ex;
+        ex.aMem = a;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwAorDasAorDAsync(int a,
+                               function<void()>,
+                               function<void(exception_ptr)> exception,
+                               const Ice::Current&)
+{
+    try
+    {
+        if(a > 0)
+        {
+            A ex;
+            ex.aMem = a;
+            throw ex;
+        }
+        else
+        {
+            D ex;
+            ex.dMem = a;
+            throw ex;
+        }
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwBasAAsync(int a, int b,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
+                         const Ice::Current&)
+{
+    try
+    {
+        B ex;
+        ex.aMem = a;
+        ex.bMem = b;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwCasAAsync(int a, int b, int c,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
+                         const Ice::Current&)
+{
+    try
+    {
+        C ex;
+        ex.aMem = a;
+        ex.bMem = b;
+        ex.cMem = c;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwBasBAsync(int a, int b,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
+                         const Ice::Current&)
+{
+    try
+    {
+        B ex;
+        ex.aMem = a;
+        ex.bMem = b;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwCasBAsync(int a, int b, int c,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
+                         const Ice::Current&)
+{
+    try
+    {
+        C ex;
+        ex.aMem = a;
+        ex.bMem = b;
+        ex.cMem = c;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwCasCAsync(int a, int b, int c,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
+                         const Ice::Current&)
+{
+    try
+    {
+        C ex;
+        ex.aMem = a;
+        ex.bMem = b;
+        ex.cMem = c;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwModAAsync(int a, int a2,
+                         function<void()>,
+                         function<void(exception_ptr)> exception,
+                         const Ice::Current&)
+{
+    Mod::A ex;
+    ex.aMem = a;
+    ex.a2Mem = a2;
+    throw ex;
+}
+
+void
+ThrowerI::throwUndeclaredAAsync(int a,
+                                function<void()>,
+                                function<void(exception_ptr)> exception,
+                                const Ice::Current&)
+{
+    try
+    {
+        A ex;
+        ex.aMem = a;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwUndeclaredBAsync(int a, int b,
+                                function<void()>,
+                                function<void(exception_ptr)>,
+                                const Ice::Current&)
+{
+    B ex;
+    ex.aMem = a;
+    ex.bMem = b;
+    throw ex;
+}
+
+void
+ThrowerI::throwUndeclaredCAsync(int a, int b, int c,
+                                function<void()>,
+                                function<void(exception_ptr)> exception,
+                                const Ice::Current&)
+{
+    try
+    {
+        C ex;
+        ex.aMem = a;
+        ex.bMem = b;
+        ex.cMem = c;
+        throw ex;
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwLocalExceptionAsync(function<void()>,
+                                   function<void(exception_ptr)> exception,
+                                   const Ice::Current&)
+{
+    try
+    {
+        throw Ice::TimeoutException(__FILE__, __LINE__);
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwNonIceExceptionAsync(function<void()>,
+                                    function<void(exception_ptr)> exception,
+                                    const Ice::Current&)
+{
+    try
+    {
+        throw int(12345);
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwAssertExceptionAsync(function<void()>,
+                                    function<void(exception_ptr)>,
+                                    const Ice::Current&)
+{
+    assert(false); // No supported in C++
+}
+
+void
+ThrowerI::throwMemoryLimitExceptionAsync(ICE_IN(Ice::ByteSeq),
+                                         function<void(const Ice::ByteSeq&)> response,
+                                         function<void(exception_ptr)>,
+                                         const Ice::Current&)
+{
+    response(Ice::ByteSeq(1024 * 20)); // 20 KB.
+}
+
+void
+ThrowerI::throwLocalExceptionIdempotentAsync(function<void()>,
+                                             function<void(exception_ptr)> exception,
+                                             const Ice::Current&)
+{
+    try
+    {
+        throw Ice::TimeoutException(__FILE__, __LINE__);
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+    
+}
+
+void
+ThrowerI::throwAfterResponseAsync(function<void()> response,
+                                  function<void(exception_ptr)>,
+                                  const Ice::Current&)
+{
+    response();
+
+    throw std::string();
+}
+
+void
+ThrowerI::throwAfterExceptionAsync(function<void()>,
+                                   function<void(exception_ptr)> exception,
+                                   const Ice::Current&)
+{
+    try
+    {
+        throw A(12345);
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+    throw std::string();
+}
+
+void
+ThrowerI::throwEAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
+                      const Ice::Current&)
+{
+    try
+    {
+        throw E("E");
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwFAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
+                      const Ice::Current&)
+{
+    try
+    {
+        throw F("F");
+    }
+    catch(...)
+    {
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwGAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
+                      const Ice::Current&)
+{
+    try
+    {
+        throw G(__FILE__, __LINE__, "G");
+    }
+    catch(const G& ex)
+    {
+        ostringstream os;
+        ex.ice_print(os);
+        test(endsWith(os.str(), "Test::G"));
+        test(ex.data == "G");
+        exception(current_exception());
+    }
+}
+
+void
+ThrowerI::throwHAsync(function<void()>,
+                      function<void(exception_ptr)> exception,
+                      const Ice::Current&)
+{
+    try
+    {
+        throw H(__FILE__, __LINE__, "H");
+    }
+    catch(const H& ex)
+    {
+        ostringstream os;
+        ex.ice_print(os);
+        test(endsWith(os.str(), "Test::H data:'H'"));
+        test(ex.data == "H");
+        exception(current_exception());
+    }
+}
+#else
+
 void
 ThrowerI::shutdown_async(const AMD_Thrower_shutdownPtr& cb,
                          const Ice::Current& current)
@@ -271,3 +660,4 @@ ThrowerI::throwH_async(const Test::AMD_Thrower_throwHPtr& cb, const Ice::Current
         cb->ice_exception(ex);
     }
 }
+#endif