merging IceBridge into master

21 files changed, 471 insertions, 142 deletions

diff --git a/cpp/test/Ice/acm/AllTests.cpp b/cpp/test/Ice/acm/AllTests.cpp
index 52c4922d98b..8e6563ede85 100644
--- a/cpp/test/Ice/acm/AllTests.cpp
+++ b/cpp/test/Ice/acm/AllTests.cpp
@@ -535,6 +535,32 @@ public:
     }
 };
 
+class HeartbeatManualTest : public TestCase
+{
+public:
+
+    HeartbeatManualTest(const RemoteCommunicatorPrxPtr& com) : TestCase("manual heartbeats", com)
+    {
+        //
+        // Disable heartbeats.
+        //
+        setClientACM(10, -1, 0);
+        setServerACM(10, -1, 0);
+    }
+
+    virtual void runTestCase(const RemoteObjectAdapterPrxPtr& adapter, const TestIntfPrxPtr& proxy)
+    {
+        proxy->startHeartbeatCount();
+        Ice::ConnectionPtr con = proxy->ice_getConnection();
+        con->heartbeat();
+        con->heartbeat();
+        con->heartbeat();
+        con->heartbeat();
+        con->heartbeat();
+        proxy->waitForHeartbeatCount(5);
+    }
+};
+
 class SetACMTest : public TestCase
 {
 public:
@@ -564,8 +590,9 @@ public:
         test(acm.close == Ice::CloseOnInvocationAndIdle);
         test(acm.heartbeat == Ice::HeartbeatAlways);
 
-        // Make sure the client sends few heartbeats to the server
-        proxy->waitForHeartbeat(2);
+        // Make sure the client sends a few heartbeats to the server.
+        proxy->startHeartbeatCount();
+        proxy->waitForHeartbeatCount(2);
     }
 };
 
@@ -591,6 +618,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
     tests.push_back(ICE_MAKE_SHARED(HeartbeatOnIdleTest, com));
     tests.push_back(ICE_MAKE_SHARED(HeartbeatAlwaysTest, com));
+    tests.push_back(ICE_MAKE_SHARED(HeartbeatManualTest, com));
     tests.push_back(ICE_MAKE_SHARED(SetACMTest, com));
 
     for(vector<TestCasePtr>::const_iterator p = tests.begin(); p != tests.end(); ++p)
diff --git a/cpp/test/Ice/acm/Test.ice b/cpp/test/Ice/acm/Test.ice
index 5ab98180dd3..d78abd6eb0f 100644
--- a/cpp/test/Ice/acm/Test.ice
+++ b/cpp/test/Ice/acm/Test.ice
@@ -17,7 +17,8 @@ interface TestIntf
     void sleep(int seconds);
     void sleepAndHold(int seconds);
     void interruptSleep();
-    void waitForHeartbeat(int count);
+    void startHeartbeatCount();
+    void waitForHeartbeatCount(int count);
 };
 
 interface RemoteObjectAdapter
diff --git a/cpp/test/Ice/acm/TestI.cpp b/cpp/test/Ice/acm/TestI.cpp
index d7742680a70..f4987856421 100644
--- a/cpp/test/Ice/acm/TestI.cpp
+++ b/cpp/test/Ice/acm/TestI.cpp
@@ -26,41 +26,6 @@ toString(int value)
     return os.str();
 }
 
-class HeartbeatCallbackI :
-#ifdef ICE_CPP11_MAPPING
-                            public enable_shared_from_this<HeartbeatCallbackI>,
-#else
-                            public Ice::HeartbeatCallback,
-#endif
-                            private IceUtil::Monitor<IceUtil::Mutex>
-{
-public:
-
-    void
-    waitForCount(int count)
-    {
-        Lock sync(*this);
-        _count = count;
-        while(_count > 0)
-        {
-            wait();
-        }
-    }
-
-    virtual void
-    heartbeat(const Ice::ConnectionPtr&)
-    {
-        Lock sync(*this);
-        --_count;
-        notifyAll();
-    }
-
-private:
-
-    int _count;
-};
-ICE_DEFINE_PTR(HeartbeatCallbackIPtr, HeartbeatCallbackI);
-
 }
 
 RemoteObjectAdapterPrxPtr
@@ -162,16 +127,23 @@ TestI::interruptSleep(const Ice::Current& current)
 }
 
 void
-TestI::waitForHeartbeat(int count, const Ice::Current& current)
+TestI::startHeartbeatCount(const Ice::Current& current)
 {
-    HeartbeatCallbackIPtr callback = ICE_MAKE_SHARED(HeartbeatCallbackI);
+    _callback = ICE_MAKE_SHARED(HeartbeatCallbackI);
 #ifdef ICE_CPP11_MAPPING
+    HeartbeatCallbackIPtr callback = _callback;
     current.con->setHeartbeatCallback([callback](Ice::ConnectionPtr connection)
     {
         callback->heartbeat(move(connection));
     });
 #else
-    current.con->setHeartbeatCallback(callback);
+    current.con->setHeartbeatCallback(_callback);
 #endif
-    callback->waitForCount(count);
+}
+
+void
+TestI::waitForHeartbeatCount(int count, const Ice::Current&)
+{
+    assert(_callback);
+    _callback->waitForCount(count);
 }
diff --git a/cpp/test/Ice/acm/TestI.h b/cpp/test/Ice/acm/TestI.h
index be031e3799d..c45415022a6 100644
--- a/cpp/test/Ice/acm/TestI.h
+++ b/cpp/test/Ice/acm/TestI.h
@@ -44,7 +44,51 @@ public:
     virtual void sleep(int, const Ice::Current&);
     virtual void sleepAndHold(int, const Ice::Current&);
     virtual void interruptSleep(const Ice::Current&);
-    virtual void waitForHeartbeat(int, const Ice::Current&);
+    virtual void startHeartbeatCount(const Ice::Current&);
+    virtual void waitForHeartbeatCount(int, const Ice::Current&);
+
+private:
+
+    class HeartbeatCallbackI :
+#ifdef ICE_CPP11_MAPPING
+                                public std::enable_shared_from_this<HeartbeatCallbackI>,
+#else
+                                public Ice::HeartbeatCallback,
+#endif
+                                private IceUtil::Monitor<IceUtil::Mutex>
+    {
+    public:
+
+        HeartbeatCallbackI() :
+            _count(0)
+        {
+        }
+
+        void
+        waitForCount(int count)
+        {
+            Lock sync(*this);
+            while(_count < count)
+            {
+                wait();
+            }
+        }
+
+        virtual void
+        heartbeat(const Ice::ConnectionPtr&)
+        {
+            Lock sync(*this);
+            ++_count;
+            notifyAll();
+        }
+
+    private:
+
+        int _count;
+    };
+    ICE_DEFINE_PTR(HeartbeatCallbackIPtr, HeartbeatCallbackI);
+
+    HeartbeatCallbackIPtr _callback;
 };
 
 #endif
diff --git a/cpp/test/Ice/ami/AllTests.cpp b/cpp/test/Ice/ami/AllTests.cpp
index 439f8a7792f..3366c4fdc7e 100644
--- a/cpp/test/Ice/ami/AllTests.cpp
+++ b/cpp/test/Ice/ami/AllTests.cpp
@@ -773,6 +773,21 @@ private:
 };
 typedef IceUtil::Handle<FlushExCallback> FlushExCallbackPtr;
 
+class CloseCallback : virtual public CallbackBase, virtual public Ice::CloseCallback
+{
+public:
+
+    CloseCallback()
+    {
+    }
+
+    virtual void closed(const Ice::ConnectionPtr& con)
+    {
+        called();
+    }
+};
+typedef IceUtil::Handle<CloseCallback> CloseCallbackPtr;
+
 class Thrower : public CallbackBase
 {
 public:
@@ -1850,7 +1865,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
             test(p->opBatchCount() == 0);
             auto b1 = p->ice_batchOneway();
             b1->opBatch();
-            b1->ice_getConnection()->close(false);
+            b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
             auto id = this_thread::get_id();
             promise<void> promise;
@@ -1924,7 +1939,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 auto b1 = Ice::uncheckedCast<Test::TestIntfPrx>(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
                 promise<void> promise;
                 b1->ice_getConnection()->flushBatchRequestsAsync(
@@ -2002,7 +2017,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 auto b1 = Ice::uncheckedCast<Test::TestIntfPrx>(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
                 promise<void> promise;
                 auto id = this_thread::get_id();
@@ -2072,8 +2087,8 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 b2->ice_getConnection(); // Ensure connection is established.
                 b1->opBatch();
                 b2->opBatch();
-                b1->ice_getConnection()->close(false);
-                b2->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
+                b2->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
                 promise<void> promise;
                 auto id = this_thread::get_id();
@@ -2161,8 +2176,38 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
 
         if(p->ice_getConnection() && protocol != "bt")
         {
-            cout << "testing close connection with sending queue... " << flush;
+            cout << "testing graceful close connection with wait... " << flush;
+            {
+                //
+                // Local case: begin several requests, close the connection gracefully, and make sure it waits
+                // for the requests to complete.
+                //
+                vector<future<void>> results;
+                for(int i = 0; i < 3; ++i)
+                {
+                    auto s = make_shared<promise<void>>();
+                    p->sleepAsync(50,
+                                  [s]() { s->set_value(); },
+                                  [s](exception_ptr ex) { s->set_exception(ex); });
+                    results.push_back(s->get_future());
+                }
+                p->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
+                for(vector<future<void>>::iterator p = results.begin(); p != results.end(); ++p)
+                {
+                    try
+                    {
+                        p->get();
+                    }
+                    catch(const Ice::LocalException&)
+                    {
+                        test(false);
+                    }
+                }
+            }
             {
+                //
+                // Remote case.
+                //
                 Ice::ByteSeq seq;
                 seq.resize(1024 * 10);
                 for(Ice::ByteSeq::iterator q = seq.begin(); q != seq.end(); ++q)
@@ -2191,7 +2236,8 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                         results.push_back(s->get_future());
                     }
                     atomic_flag sent = ATOMIC_FLAG_INIT;
-                    p->closeAsync(false, nullptr, nullptr, [&sent](bool) { sent.test_and_set(); });
+                    p->closeAsync(Test::CloseMode::CloseGracefullyAndWait, nullptr, nullptr,
+                                  [&sent](bool) { sent.test_and_set(); });
                     if(!sent.test_and_set())
                     {
                         for(int i = 0; i < maxQueue; i++)
@@ -2231,8 +2277,111 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 }
             }
             cout << "ok" << endl;
-        }
 
+            cout << "testing graceful close connection without wait... " << flush;
+            {
+                //
+                // Local case: start a lengthy operation and then close the connection gracefully on the client side
+                // without waiting for the pending invocation to complete. There will be no retry and we expect the
+                // invocation to fail with ConnectionManuallyClosedException.
+                //
+                // This test requires two threads in the server's thread pool: one will block in sleep() and the other
+                // will process the CloseConnection message.
+                // 
+                p->ice_ping();
+                auto con = p->ice_getConnection();
+                auto s = make_shared<promise<void>>();
+                p->sleepAsync(100,
+                              [s]() { s->set_value(); },
+                              [s](exception_ptr ex) { s->set_exception(ex); });
+                future<void> f = s->get_future();
+                con->close(Ice::ConnectionClose::CloseGracefully);
+                try
+                {
+                    f.get();
+                    test(false);
+                }
+                catch(const Ice::ConnectionManuallyClosedException& ex)
+                {
+                    test(ex.graceful);
+                }
+
+                //
+                // Remote case: the server closes the connection gracefully. Our call to TestIntf::close()
+                // completes successfully and then the connection should be closed immediately afterward,
+                // despite the fact that there's a pending call to sleep(). The call to sleep() should be
+                // automatically retried and complete successfully with a new connection.
+                //
+                p->ice_ping();
+                con = p->ice_getConnection();
+                auto sc = make_shared<promise<void>>();
+                con->setCloseCallback(
+                    [sc](Ice::ConnectionPtr connection)
+                    {
+                        sc->set_value();
+                    });
+                future<void> fc = sc->get_future();
+                s = make_shared<promise<void>>();
+                p->sleepAsync(100,
+                              [s]() { s->set_value(); },
+                              [s](exception_ptr ex) { s->set_exception(ex); });
+                f = s->get_future();
+                p->close(Test::CloseMode::CloseGracefully);
+                fc.get();
+                try
+                {
+                    f.get();
+                }
+                catch(const Ice::LocalException&)
+                {
+                    test(false);
+                }
+                p->ice_ping();
+                test(p->ice_getConnection() != con);
+            }
+            cout << "ok" << endl;
+
+            cout << "testing forceful close connection... " << flush;
+            {
+                //
+                // Local case: start a lengthy operation and then close the connection forcefully on the client side.
+                // There will be no retry and we expect the invocation to fail with ConnectionManuallyClosedException.
+                // 
+                p->ice_ping();
+                auto con = p->ice_getConnection();
+                auto s = make_shared<promise<void>>();
+                p->sleepAsync(100,
+                              [s]() { s->set_value(); },
+                              [s](exception_ptr ex) { s->set_exception(ex); });
+                future<void> f = s->get_future();
+                con->close(Ice::ConnectionClose::CloseForcefully);
+                try
+                {
+                    f.get();
+                    test(false);
+                }
+                catch(const Ice::ConnectionManuallyClosedException& ex)
+                {
+                    test(!ex.graceful);
+                }
+
+                //
+                // Remote case: the server closes the connection forcefully. This causes the request to fail
+                // with a ConnectionLostException. Since the close() operation is not idempotent, the client
+                // will not retry.
+                //
+                try
+                {
+                    p->close(Test::CloseMode::CloseForcefully);
+                    test(false);
+                }
+                catch(const Ice::ConnectionLostException&)
+                {
+                    // Expected.
+                }
+            }
+            cout << "ok" << endl;
+        }
     }
 
     p->shutdown();
@@ -2944,7 +3093,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 test(p->opBatchCount() == 0);
                 Test::TestIntfPrx b1 = p->ice_batchOneway();
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = b1->begin_ice_flushBatchRequests(
                     Ice::newCallback(cb, &FlushCallback::completedAsync, &FlushCallback::sentAsync));
@@ -2962,7 +3111,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 test(p->opBatchCount() == 0);
                 Test::TestIntfPrx b1 = p->ice_batchOneway();
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback(cookie);
                 b1->begin_ice_flushBatchRequests(
                     Ice::newCallback(cb, &FlushCallback::completedAsync, &FlushCallback::sentAsync), cookie);
@@ -3013,7 +3162,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 test(p->opBatchCount() == 0);
                 Test::TestIntfPrx b1 = p->ice_batchOneway();
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = b1->begin_ice_flushBatchRequests(
                     Ice::newCallback_Object_ice_flushBatchRequests(cb, &FlushCallback::exception,
@@ -3031,7 +3180,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 test(p->opBatchCount() == 0);
                 Test::TestIntfPrx b1 = p->ice_batchOneway();
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback(cookie);
                 b1->begin_ice_flushBatchRequests(
                     Ice::newCallback_Object_ice_flushBatchRequests(cb, &FlushCallback::exceptionWC,
@@ -3100,7 +3249,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushExCallbackPtr cb = new FlushExCallback();
                 Ice::AsyncResultPtr r = b1->ice_getConnection()->begin_flushBatchRequests(
                     Ice::newCallback(cb, &FlushExCallback::completedAsync, &FlushExCallback::sentAsync));
@@ -3119,7 +3268,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushExCallbackPtr cb = new FlushExCallback(cookie);
                 b1->ice_getConnection()->begin_flushBatchRequests(
                     Ice::newCallback(cb, &FlushExCallback::completedAsync, &FlushExCallback::sentAsync), cookie);
@@ -3171,7 +3320,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushExCallbackPtr cb = new FlushExCallback();
                 Ice::AsyncResultPtr r = b1->ice_getConnection()->begin_flushBatchRequests(
                     Ice::newCallback_Connection_flushBatchRequests(cb, &FlushExCallback::exception,
@@ -3191,7 +3340,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushExCallbackPtr cb = new FlushExCallback(cookie);
                 b1->ice_getConnection()->begin_flushBatchRequests(
                     Ice::newCallback_Connection_flushBatchRequests(cb, &FlushExCallback::exceptionWC,
@@ -3249,7 +3398,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = communicator->begin_flushBatchRequests(
                     Ice::newCallback(cb, &FlushCallback::completedAsync, &FlushCallback::sentAsync));
@@ -3268,7 +3417,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback(cookie);
                 communicator->begin_flushBatchRequests(
                     Ice::newCallback(cb, &FlushCallback::completedAsync, &FlushCallback::sentAsync), cookie);
@@ -3319,7 +3468,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 b2->ice_getConnection(); // Ensure connection is established.
                 b1->opBatch();
                 b2->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = communicator->begin_flushBatchRequests(
                     Ice::newCallback(cb, &FlushCallback::completedAsync, &FlushCallback::sentAsync));
@@ -3346,8 +3495,8 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 b2->ice_getConnection(); // Ensure connection is established.
                 b1->opBatch();
                 b2->opBatch();
-                b1->ice_getConnection()->close(false);
-                b2->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
+                b2->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = communicator->begin_flushBatchRequests(
                     Ice::newCallback(cb, &FlushCallback::completedAsync, &FlushCallback::sentAsync));
@@ -3402,7 +3551,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = communicator->begin_flushBatchRequests(
                     Ice::newCallback_Communicator_flushBatchRequests(cb, &FlushCallback::exception,
@@ -3422,7 +3571,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 Test::TestIntfPrx b1 = Test::TestIntfPrx::uncheckedCast(
                     p->ice_getConnection()->createProxy(p->ice_getIdentity())->ice_batchOneway());
                 b1->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback(cookie);
                 communicator->begin_flushBatchRequests(
                     Ice::newCallback_Communicator_flushBatchRequests(cb, &FlushCallback::exceptionWC,
@@ -3476,7 +3625,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 b2->ice_getConnection(); // Ensure connection is established.
                 b1->opBatch();
                 b2->opBatch();
-                b1->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = communicator->begin_flushBatchRequests(
                     Ice::newCallback_Communicator_flushBatchRequests(cb, &FlushCallback::exception,
@@ -3504,8 +3653,8 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 b2->ice_getConnection(); // Ensure connection is established.
                 b1->opBatch();
                 b2->opBatch();
-                b1->ice_getConnection()->close(false);
-                b2->ice_getConnection()->close(false);
+                b1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
+                b2->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 FlushCallbackPtr cb = new FlushCallback();
                 Ice::AsyncResultPtr r = communicator->begin_flushBatchRequests(
                     Ice::newCallback_Communicator_flushBatchRequests(cb, &FlushCallback::exception,
@@ -3715,8 +3864,35 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
 
     if(p->ice_getConnection() && protocol != "bt")
     {
-        cout << "testing close connection with sending queue... " << flush;
+        cout << "testing graceful close connection with wait... " << flush;
+        {
+            //
+            // Local case: begin several requests, close the connection gracefully, and make sure it waits
+            // for the requests to complete.
+            //
+            vector<Ice::AsyncResultPtr> results;
+            for(int i = 0; i < 3; ++i)
+            {
+                results.push_back(p->begin_sleep(50));
+            }
+            p->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
+            for(vector<Ice::AsyncResultPtr>::const_iterator q = results.begin(); q != results.end(); ++q)
+            {
+                (*q)->waitForCompleted();
+                try
+                {
+                    (*q)->throwLocalException();
+                }
+                catch(const Ice::LocalException&)
+                {
+                    test(false);
+                }
+            }
+        }
         {
+            //
+            // Remote case.
+            //
             Ice::ByteSeq seq;
             seq.resize(1024 * 10);
             for(Ice::ByteSeq::iterator q = seq.begin(); q != seq.end(); ++q)
@@ -3740,7 +3916,7 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
                 {
                     results.push_back(p->begin_opWithPayload(seq));
                 }
-                if(!p->begin_close(false)->isSent())
+                if(!p->begin_close(Test::CloseGracefullyAndWait)->isSent())
                 {
                     for(int i = 0; i < maxQueue; i++)
                     {
@@ -3775,6 +3951,96 @@ allTests(const Ice::CommunicatorPtr& communicator, bool collocated)
             }
         }
         cout << "ok" << endl;
+
+        cout << "testing graceful close connection without wait... " << flush;
+        {
+            //
+            // Local case: start a lengthy operation and then close the connection gracefully on the client side
+            // without waiting for the pending invocation to complete. There will be no retry and we expect the
+            // invocation to fail with ConnectionManuallyClosedException.
+            //
+            // This test requires two threads in the server's thread pool: one will block in sleep() and the other
+            // will process the CloseConnection message.
+            // 
+            p->ice_ping();
+            Ice::ConnectionPtr con = p->ice_getConnection();
+            Ice::AsyncResultPtr r = p->begin_sleep(100);
+            con->close(Ice::CloseGracefully);
+            r->waitForCompleted();
+            try
+            {
+                r->throwLocalException();
+                test(false);
+            }
+            catch(const Ice::ConnectionManuallyClosedException& ex)
+            {
+                test(ex.graceful);
+            }
+
+            //
+            // Remote case: the server closes the connection gracefully. Our call to TestIntf::close()
+            // completes successfully and then the connection should be closed immediately afterward,
+            // despite the fact that there's a pending call to sleep(). The call to sleep() should be
+            // automatically retried and complete successfully.
+            //
+            p->ice_ping();
+            con = p->ice_getConnection();
+            CloseCallbackPtr cb = new CloseCallback;
+            con->setCloseCallback(cb);
+            r = p->begin_sleep(100);
+            p->close(Test::CloseGracefully);
+            cb->check();
+            r->waitForCompleted();
+            try
+            {
+                r->throwLocalException();
+            }
+            catch(const Ice::LocalException&)
+            {
+                test(false);
+            }
+            p->ice_ping();
+            test(p->ice_getConnection() != con);
+        }
+        cout << "ok" << endl;
+
+        cout << "testing forceful close connection... " << flush;
+        {
+            //
+            // Local case: start a lengthy operation and then close the connection forcefully on the client side.
+            // There will be no retry and we expect the invocation to fail with ConnectionManuallyClosedException.
+            // 
+            p->ice_ping();
+            Ice::ConnectionPtr con = p->ice_getConnection();
+            Ice::AsyncResultPtr r = p->begin_sleep(100);
+            con->close(Ice::CloseForcefully);
+            r->waitForCompleted();
+            try
+            {
+                r->throwLocalException();
+                test(false);
+            }
+            catch(const Ice::ConnectionManuallyClosedException& ex)
+            {
+                test(!ex.graceful);
+            }
+
+            //
+            // Remote case: the server closes the connection forcefully. This causes the request to fail
+            // with a ConnectionLostException. Since the close() operation is not idempotent, the client
+            // will not retry.
+            //
+            try
+            {
+                p->close(Test::CloseForcefully);
+                test(false);
+            }
+            catch(const Ice::ConnectionLostException&)
+            {
+                // Expected.
+            }
+        }
+        cout << "ok" << endl;
     }
 
     p->shutdown();
diff --git a/cpp/test/Ice/ami/Client.cpp b/cpp/test/Ice/ami/Client.cpp
index 18fb26c44bb..c6915bc2557 100644
--- a/cpp/test/Ice/ami/Client.cpp
+++ b/cpp/test/Ice/ami/Client.cpp
@@ -37,6 +37,7 @@ main(int argc, char* argv[])
     {
         Ice::InitializationData initData = getTestInitData(argc, argv);
         initData.properties->setProperty("Ice.Warn.AMICallback", "0");
+        initData.properties->setProperty("Ice.Warn.Connections", "0");
 
         //
         // Limit the send buffer size, this test relies on the socket
diff --git a/cpp/test/Ice/ami/Test.ice b/cpp/test/Ice/ami/Test.ice
index 289750a3eb2..c82910e4620 100644
--- a/cpp/test/Ice/ami/Test.ice
+++ b/cpp/test/Ice/ami/Test.ice
@@ -19,6 +19,13 @@ exception TestIntfException
 {
 };
 
+enum CloseMode
+{
+    CloseForcefully,
+    CloseGracefully,
+    CloseGracefullyAndWait
+};
+
 interface TestIntf
 {
     void op();
@@ -34,7 +41,8 @@ interface TestIntf
                     out int eight, out int nine, out int ten, out int eleven);
     int opBatchCount();
     bool waitForBatch(int count);
-    void close(bool force);
+    void close(CloseMode mode);
+    void sleep(int ms);
     void shutdown();
 
     bool supportsFunctionalTests();
diff --git a/cpp/test/Ice/ami/TestI.cpp b/cpp/test/Ice/ami/TestI.cpp
index f2dab5afd70..d7aa1d44762 100644
--- a/cpp/test/Ice/ami/TestI.cpp
+++ b/cpp/test/Ice/ami/TestI.cpp
@@ -93,9 +93,16 @@ TestIntfI::waitForBatch(Ice::Int count, const Ice::Current&)
 }
 
 void
-TestIntfI::close(bool force, const Ice::Current& current)
+TestIntfI::close(Test::CloseMode mode, const Ice::Current& current)
 {
-    current.con->close(force);
+    current.con->close(static_cast<ConnectionClose>(mode));
+}
+
+void
+TestIntfI::sleep(Ice::Int ms, const Ice::Current& current)
+{
+    IceUtil::Monitor<IceUtil::Mutex>::Lock sync(*this);
+    timedWait(IceUtil::Time::milliSeconds(ms));
 }
 
 void
diff --git a/cpp/test/Ice/ami/TestI.h b/cpp/test/Ice/ami/TestI.h
index bee3571b74b..edde85f6008 100644
--- a/cpp/test/Ice/ami/TestI.h
+++ b/cpp/test/Ice/ami/TestI.h
@@ -32,7 +32,8 @@ public:
     virtual void opWithArgs(Ice::Int&, Ice::Int&, Ice::Int&, Ice::Int&, Ice::Int&, Ice::Int&, Ice::Int&,
                             Ice::Int&, Ice::Int&, Ice::Int&, Ice::Int&, const Ice::Current&);
     virtual bool waitForBatch(Ice::Int, const Ice::Current&);
-    virtual void close(bool, const Ice::Current&);
+    virtual void close(Test::CloseMode, const Ice::Current&);
+    virtual void sleep(Ice::Int, const Ice::Current&);
     virtual void shutdown(const Ice::Current&);
 
     virtual bool supportsFunctionalTests(const Ice::Current&);
diff --git a/cpp/test/Ice/background/AllTests.cpp b/cpp/test/Ice/background/AllTests.cpp
index f5fdc059870..4d6b82904d6 100644
--- a/cpp/test/Ice/background/AllTests.cpp
+++ b/cpp/test/Ice/background/AllTests.cpp
@@ -379,7 +379,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
 #ifdef ICE_CPP11_MAPPING
         background->opAsync();
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
         background->opAsync();
 
         vector<future<void>> results;
@@ -407,7 +407,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         }
 #else
         background->begin_op();
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
         background->begin_op();
 
         vector<Ice::AsyncResultPtr> results;
@@ -452,7 +452,7 @@ connectTests(const ConfigurationPtr& configuration, const Test::BackgroundPrxPtr
     {
         test(false);
     }
-    background->ice_getConnection()->close(false);
+    background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
     int i;
     for(i = 0; i < 4; ++i)
@@ -560,7 +560,7 @@ connectTests(const ConfigurationPtr& configuration, const Test::BackgroundPrxPtr
         }
 
         configuration->connectException(new Ice::SocketException(__FILE__, __LINE__));
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
         IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
         configuration->connectException(0);
         try
@@ -592,7 +592,7 @@ initializeTests(const ConfigurationPtr& configuration,
     {
         test(false);
     }
-    background->ice_getConnection()->close(false);
+    background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
     int i;
     for(i = 0; i < 4; i++)
@@ -682,7 +682,7 @@ initializeTests(const ConfigurationPtr& configuration,
         cerr << ex << endl;
         test(false);
     }
-    background->ice_getConnection()->close(false);
+    background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
     try
     {
@@ -695,7 +695,7 @@ initializeTests(const ConfigurationPtr& configuration,
         cerr << ex << endl;
         test(false);
     }
-    background->ice_getConnection()->close(false);
+    background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 #endif
 
     //
@@ -728,7 +728,7 @@ initializeTests(const ConfigurationPtr& configuration,
     {
         test(false);
     }
-    background->ice_getConnection()->close(false);
+    background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
     try
     {
@@ -764,7 +764,7 @@ initializeTests(const ConfigurationPtr& configuration,
         }
 
         configuration->initializeException(new Ice::SocketException(__FILE__, __LINE__));
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
         IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
         configuration->initializeException(0);
         try
@@ -784,12 +784,12 @@ initializeTests(const ConfigurationPtr& configuration,
         }
 
         configuration->initializeSocketOperation(IceInternal::SocketOperationWrite);
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
         background->ice_ping();
         configuration->initializeSocketOperation(IceInternal::SocketOperationNone);
 
         ctl->initializeException(true);
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
         IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
         ctl->initializeException(false);
         try
@@ -812,11 +812,11 @@ initializeTests(const ConfigurationPtr& configuration,
         {
 #if !defined(ICE_USE_IOCP) && !defined(ICE_USE_CFSTREAM)
             ctl->initializeSocketOperation(IceInternal::SocketOperationWrite);
-            background->ice_getCachedConnection()->close(true);
+            background->ice_getCachedConnection()->close(Ice::CloseForcefully);
             background->op();
             ctl->initializeSocketOperation(IceInternal::SocketOperationNone);
 #else
-            background->ice_getCachedConnection()->close(true);
+            background->ice_getCachedConnection()->close(Ice::CloseForcefully);
             background->op();
 #endif
         }
@@ -847,7 +847,7 @@ validationTests(const ConfigurationPtr& configuration,
     {
         test(false);
     }
-    background->ice_getConnection()->close(false);
+    background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
     try
     {
@@ -921,7 +921,7 @@ validationTests(const ConfigurationPtr& configuration,
             cerr << ex << endl;
             test(false);
         }
-        background->ice_getConnection()->close(false);
+        background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
         try
         {
@@ -1081,7 +1081,7 @@ validationTests(const ConfigurationPtr& configuration,
         cerr << ex << endl;
         test(false);
     }
-    background->ice_getConnection()->close(false);
+    background->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
     try
     {
@@ -1163,7 +1163,7 @@ validationTests(const ConfigurationPtr& configuration,
 #else
     backgroundBatchOneway->begin_ice_flushBatchRequests();
 #endif
-    backgroundBatchOneway->ice_getConnection()->close(false);
+    backgroundBatchOneway->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
     ctl->holdAdapter();
     backgroundBatchOneway->opWithPayload(seq);
@@ -1183,10 +1183,10 @@ validationTests(const ConfigurationPtr& configuration,
     // in the flush to report a CloseConnectionException). Instead we
     // wait for the first flush to complete.
     //
-    //backgroundBatchOneway->ice_getConnection()->close(false);
+    //backgroundBatchOneway->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
     backgroundBatchOneway->end_ice_flushBatchRequests(r);
 #endif
-    backgroundBatchOneway->ice_getConnection()->close(false);
+    backgroundBatchOneway->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 }
 
 void
@@ -1775,10 +1775,10 @@ readWriteTests(const ConfigurationPtr& configuration,
         IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
 
         background->ice_ping();
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
         IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10));
 
-        background->ice_getCachedConnection()->close(true);
+        background->ice_getCachedConnection()->close(Ice::CloseForcefully);
     }
 
     thread1->destroy();
diff --git a/cpp/test/Ice/binding/AllTests.cpp b/cpp/test/Ice/binding/AllTests.cpp
index a8d5f454a74..26e7fa48aa6 100644
--- a/cpp/test/Ice/binding/AllTests.cpp
+++ b/cpp/test/Ice/binding/AllTests.cpp
@@ -170,7 +170,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(test2->ice_getConnection() == test3->ice_getConnection());
 
             names.erase(test1->getAdapterName());
-            test1->ice_getConnection()->close(false);
+            test1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         }
 
         //
@@ -192,7 +192,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
             for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
             {
-                (*q)->getTestIntf()->ice_getConnection()->close(false);
+                (*q)->getTestIntf()->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             }
         }
 
@@ -217,7 +217,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(test2->ice_getConnection() == test3->ice_getConnection());
 
             names.erase(test1->getAdapterName());
-            test1->ice_getConnection()->close(false);
+            test1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         }
 
         //
@@ -314,7 +314,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             {
                 try
                 {
-                    (*q)->getTestIntf()->ice_getConnection()->close(false);
+                    (*q)->getTestIntf()->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
                 }
                 catch(const Ice::LocalException&)
                 {
@@ -354,7 +354,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(test2->ice_getConnection() == test3->ice_getConnection());
 
             names.erase(getAdapterNameWithAMI(test1));
-            test1->ice_getConnection()->close(false);
+            test1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         }
 
         //
@@ -376,7 +376,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 
             for(vector<RemoteObjectAdapterPrxPtr>::const_iterator q = adapters.begin(); q != adapters.end(); ++q)
             {
-                (*q)->getTestIntf()->ice_getConnection()->close(false);
+                (*q)->getTestIntf()->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             }
         }
 
@@ -401,7 +401,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             test(test2->ice_getConnection() == test3->ice_getConnection());
 
             names.erase(test1->getAdapterName());
-            test1->ice_getConnection()->close(false);
+            test1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         }
 
         //
@@ -433,7 +433,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         while(!names.empty())
         {
             names.erase(test->getAdapterName());
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         }
 
         test = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_endpointSelection(Ice::Random));
@@ -445,7 +445,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         while(!names.empty())
         {
             names.erase(test->getAdapterName());
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         }
 
         deactivate(com, adapters);
@@ -473,7 +473,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 #if TARGET_OS_IPHONE > 0
         if(i != nRetry)
         {
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             for(i = 0; i < nRetry && test->getAdapterName() == "Adapter31"; i++);
         }
 #endif
@@ -483,7 +483,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 #if TARGET_OS_IPHONE > 0
         if(i != nRetry)
         {
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             for(i = 0; i < nRetry && test->getAdapterName() == "Adapter32"; i++);
         }
 #endif
@@ -493,7 +493,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
 #if TARGET_OS_IPHONE > 0
         if(i != nRetry)
         {
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             for(i = 0; i < nRetry && test->getAdapterName() == "Adapter33"; i++);
         }
 #endif
@@ -525,29 +525,29 @@ allTests(const Ice::CommunicatorPtr& communicator)
 #if TARGET_OS_IPHONE > 0
         if(i != nRetry)
         {
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             for(i = 0; i < nRetry && test->getAdapterName() == "Adapter36"; i++);
         }
 #endif
         test(i == nRetry);
-        test->ice_getConnection()->close(false);
+        test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         adapters.push_back(com->createObjectAdapter("Adapter35", endpoints[1]->toString()));
         for(i = 0; i < nRetry && test->getAdapterName() == "Adapter35"; i++);
 #if TARGET_OS_IPHONE > 0
         if(i != nRetry)
         {
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             for(i = 0; i < nRetry && test->getAdapterName() == "Adapter35"; i++);
         }
 #endif
         test(i == nRetry);
-        test->ice_getConnection()->close(false);
+        test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         adapters.push_back(com->createObjectAdapter("Adapter34", endpoints[0]->toString()));
         for(i = 0; i < nRetry && test->getAdapterName() == "Adapter34"; i++);
 #if TARGET_OS_IPHONE > 0
         if(i != nRetry)
         {
-            test->ice_getConnection()->close(false);
+            test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             for(i = 0; i < nRetry && test->getAdapterName() == "Adapter34"; i++);
         }
 #endif
@@ -865,7 +865,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             for(i = 0; i < 5; i++)
             {
                 test(test->getAdapterName() == "Adapter82");
-                test->ice_getConnection()->close(false);
+                test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             }
 
             TestIntfPrxPtr testSecure = ICE_UNCHECKED_CAST(TestIntfPrx, test->ice_secure(true));
@@ -881,7 +881,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             for(i = 0; i < 5; i++)
             {
                 test(test->getAdapterName() == "Adapter81");
-                test->ice_getConnection()->close(false);
+                test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             }
 
             com->createObjectAdapter("Adapter83", (test->ice_getEndpoints()[1])->toString()); // Reactive tcp OA.
@@ -889,7 +889,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             for(i = 0; i < 5; i++)
             {
                 test(test->getAdapterName() == "Adapter83");
-                test->ice_getConnection()->close(false);
+                test->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             }
 
             com->deactivateObjectAdapter(adapters[0]);
@@ -1098,7 +1098,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             // Close the connection now to free a FD (it could be done after the sleep but
             // there could be race condiutation since the connection might not be closed
             // immediately due to threading).
-            test->ice_connectionId("0")->ice_getConnection()->close(false);
+            test->ice_connectionId("0")->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
             //
             // The server closed the acceptor, wait one second and retry after freeing a FD.
diff --git a/cpp/test/Ice/hold/AllTests.cpp b/cpp/test/Ice/hold/AllTests.cpp
index d08764d57d8..7cb0e59a53c 100644
--- a/cpp/test/Ice/hold/AllTests.cpp
+++ b/cpp/test/Ice/hold/AllTests.cpp
@@ -290,7 +290,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             {
                 completed->get_future().get();
                 holdSerialized->ice_ping(); // Ensure everything's dispatched
-                holdSerialized->ice_getConnection()->close(false);
+                holdSerialized->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             }
         }
         completed->get_future().get();
@@ -305,7 +305,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
             {
                 result->waitForSent();
                 holdSerialized->ice_ping(); // Ensure everything's dispatched
-                holdSerialized->ice_getConnection()->close(false);
+                holdSerialized->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
             }
         }
         result->waitForCompleted();
diff --git a/cpp/test/Ice/location/AllTests.cpp b/cpp/test/Ice/location/AllTests.cpp
index 148230c9fbf..4e96a75a0d5 100644
--- a/cpp/test/Ice/location/AllTests.cpp
+++ b/cpp/test/Ice/location/AllTests.cpp
@@ -637,7 +637,7 @@ allTests(const Ice::CommunicatorPtr& communicator, const string& ref)
     cout << "testing object migration... " << flush;
     hello = ICE_CHECKED_CAST(HelloPrx, communicator->stringToProxy("hello"));
     obj->migrateHello();
-    hello->ice_getConnection()->close(false);
+    hello->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
     hello->sayHello();
     obj->migrateHello();
     hello->sayHello();
diff --git a/cpp/test/Ice/metrics/AllTests.cpp b/cpp/test/Ice/metrics/AllTests.cpp
index c880af199ce..8d30231b520 100644
--- a/cpp/test/Ice/metrics/AllTests.cpp
+++ b/cpp/test/Ice/metrics/AllTests.cpp
@@ -287,7 +287,7 @@ struct Connect
     {
         if(proxy->ice_getCachedConnection())
         {
-            proxy->ice_getCachedConnection()->close(false);
+            proxy->ice_getCachedConnection()->close(Ice::CloseGracefullyAndWait);
         }
         try
         {
@@ -298,7 +298,7 @@ struct Connect
         }
         if(proxy->ice_getCachedConnection())
         {
-            proxy->ice_getCachedConnection()->close(false);
+            proxy->ice_getCachedConnection()->close(Ice::CloseGracefullyAndWait);
         }
     }
 
@@ -534,8 +534,8 @@ allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPt
 
     if(!collocated)
     {
-        metrics->ice_getConnection()->close(false);
-        metrics->ice_connectionId("Con1")->ice_getConnection()->close(false);
+        metrics->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
+        metrics->ice_connectionId("Con1")->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
         waitForCurrent(clientMetrics, "View", "Connection", 0);
         waitForCurrent(serverMetrics, "View", "Connection", 0);
@@ -645,7 +645,7 @@ allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPt
         map = toMap(serverMetrics->getMetricsView("View", timestamp)["Connection"]);
         test(map["holding"]->current == 1);
 
-        metrics->ice_getConnection()->close(false);
+        metrics->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
         map = toMap(clientMetrics->getMetricsView("View", timestamp)["Connection"]);
         test(map["closing"]->current == 1);
@@ -660,7 +660,7 @@ allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPt
         props["IceMX.Metrics.View.Map.Connection.GroupBy"] = "none";
         updateProps(clientProps, serverProps, update.get(), props, "Connection");
 
-        metrics->ice_getConnection()->close(false);
+        metrics->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
         metrics->ice_timeout(500)->ice_ping();
         controller->hold();
@@ -717,7 +717,7 @@ allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPt
         testAttribute(clientMetrics, clientProps, update.get(), "Connection", "mcastHost", "");
         testAttribute(clientMetrics, clientProps, update.get(), "Connection", "mcastPort", "");
 
-        m->ice_getConnection()->close(false);
+        m->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
         waitForCurrent(clientMetrics, "View", "Connection", 0);
         waitForCurrent(serverMetrics, "View", "Connection", 0);
@@ -736,7 +736,7 @@ allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPt
         IceMX::MetricsPtr m1 = clientMetrics->getMetricsView("View", timestamp)["ConnectionEstablishment"][0];
         test(m1->current == 0 && m1->total == 1 && m1->id == hostAndPort);
 
-        metrics->ice_getConnection()->close(false);
+        metrics->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         controller->hold();
         try
         {
@@ -788,7 +788,7 @@ allTests(const Ice::CommunicatorPtr& communicator, const CommunicatorObserverIPt
         try
         {
             prx->ice_ping();
-            prx->ice_getConnection()->close(false);
+            prx->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         }
         catch(const Ice::LocalException&)
         {
diff --git a/cpp/test/Ice/metrics/TestAMDI.cpp b/cpp/test/Ice/metrics/TestAMDI.cpp
index 621bc976c1d..d5173e4380b 100644
--- a/cpp/test/Ice/metrics/TestAMDI.cpp
+++ b/cpp/test/Ice/metrics/TestAMDI.cpp
@@ -22,7 +22,7 @@ MetricsI::opAsync(function<void()> response, function<void(exception_ptr)>, cons
 void
 MetricsI::failAsync(function<void()> response, function<void(exception_ptr)>, const Ice::Current& current)
 {
-    current.con->close(true);
+    current.con->close(Ice::CloseForcefully);
     response();
 }
 
@@ -87,7 +87,7 @@ MetricsI::op_async(const Test::AMD_Metrics_opPtr& cb, const Ice::Current&)
 void
 MetricsI::fail_async(const Test::AMD_Metrics_failPtr& cb, const Ice::Current& current)
 {
-    current.con->close(true);
+    current.con->close(Ice::CloseForcefully);
     cb->ice_response();
 }
 
diff --git a/cpp/test/Ice/metrics/TestI.cpp b/cpp/test/Ice/metrics/TestI.cpp
index 24e7b9b8ec3..30f7a98bf35 100644
--- a/cpp/test/Ice/metrics/TestI.cpp
+++ b/cpp/test/Ice/metrics/TestI.cpp
@@ -18,7 +18,7 @@ MetricsI::op(const Ice::Current&)
 void
 MetricsI::fail(const Ice::Current& current)
 {
-    current.con->close(true);
+    current.con->close(Ice::CloseForcefully);
 }
 
 void
diff --git a/cpp/test/Ice/operations/BatchOneways.cpp b/cpp/test/Ice/operations/BatchOneways.cpp
index cc86c14a951..e3d261cf7e3 100644
--- a/cpp/test/Ice/operations/BatchOneways.cpp
+++ b/cpp/test/Ice/operations/BatchOneways.cpp
@@ -121,7 +121,7 @@ batchOneways(const Test::MyClassPrxPtr& p)
         batch1->ice_ping();
         batch2->ice_ping();
         batch1->ice_flushBatchRequests();
-        batch1->ice_getConnection()->close(false);
+        batch1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         batch1->ice_ping();
         batch2->ice_ping();
 
@@ -129,7 +129,7 @@ batchOneways(const Test::MyClassPrxPtr& p)
         batch2->ice_getConnection();
 
         batch1->ice_ping();
-        batch1->ice_getConnection()->close(false);
+        batch1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         batch1->ice_ping();
         batch2->ice_ping();
     }
diff --git a/cpp/test/Ice/operations/BatchOnewaysAMI.cpp b/cpp/test/Ice/operations/BatchOnewaysAMI.cpp
index 9adb2be5c7b..4545d8581cf 100644
--- a/cpp/test/Ice/operations/BatchOnewaysAMI.cpp
+++ b/cpp/test/Ice/operations/BatchOnewaysAMI.cpp
@@ -127,7 +127,7 @@ batchOnewaysAMI(const Test::MyClassPrxPtr& p)
         batch1->ice_pingAsync().get();
         batch2->ice_pingAsync().get();
         batch1->ice_flushBatchRequestsAsync().get();
-        batch1->ice_getConnection()->close(false);
+        batch1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         batch1->ice_pingAsync().get();
         batch2->ice_pingAsync().get();
 
@@ -135,7 +135,7 @@ batchOnewaysAMI(const Test::MyClassPrxPtr& p)
         batch2->ice_getConnection();
 
         batch1->ice_pingAsync().get();
-        batch1->ice_getConnection()->close(false);
+        batch1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
         batch1->ice_pingAsync().get();
         batch2->ice_pingAsync().get();
@@ -182,7 +182,7 @@ batchOnewaysAMI(const Test::MyClassPrxPtr& p)
         batch1->end_ice_ping(batch1->begin_ice_ping());
         batch2->end_ice_ping(batch2->begin_ice_ping());
         batch1->end_ice_flushBatchRequests(batch1->begin_ice_flushBatchRequests());
-        batch1->ice_getConnection()->close(false);
+        batch1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
         batch1->end_ice_ping(batch1->begin_ice_ping());
         batch2->end_ice_ping(batch2->begin_ice_ping());
 
@@ -190,7 +190,7 @@ batchOnewaysAMI(const Test::MyClassPrxPtr& p)
         batch2->ice_getConnection();
 
         batch1->end_ice_ping(batch1->begin_ice_ping());
-        batch1->ice_getConnection()->close(false);
+        batch1->ice_getConnection()->close(Ice::CloseGracefullyAndWait);
 
         batch1->end_ice_ping(batch1->begin_ice_ping());
         batch2->end_ice_ping(batch2->begin_ice_ping());
diff --git a/cpp/test/Ice/retry/TestI.cpp b/cpp/test/Ice/retry/TestI.cpp
index f721a3b6ab7..7fd3c0d4dd4 100644
--- a/cpp/test/Ice/retry/TestI.cpp
+++ b/cpp/test/Ice/retry/TestI.cpp
@@ -22,7 +22,7 @@ RetryI::op(bool kill, const Ice::Current& current)
     {
         if(current.con)
         {
-            current.con->close(true);
+            current.con->close(Ice::CloseForcefully);
         }
         else
         {
diff --git a/cpp/test/Ice/timeout/AllTests.cpp b/cpp/test/Ice/timeout/AllTests.cpp
index 6681a8f56df..1947f4e9aa1 100644
--- a/cpp/test/Ice/timeout/AllTests.cpp
+++ b/cpp/test/Ice/timeout/AllTests.cpp
@@ -294,7 +294,7 @@ allTests(const Ice::CommunicatorPtr& communicator)
         TimeoutPrxPtr to = ICE_CHECKED_CAST(TimeoutPrx, obj->ice_timeout(250));
         Ice::ConnectionPtr connection = to->ice_getConnection();
         timeout->holdAdapter(600);
-        connection->close(false);
+        connection->close(Ice::CloseGracefullyAndWait);
         try
         {
             connection->getInfo(); // getInfo() doesn't throw in the closing state.
@@ -309,9 +309,10 @@ allTests(const Ice::CommunicatorPtr& communicator)
             connection->getInfo();
             test(false);
         }
-        catch(const Ice::CloseConnectionException&)
+        catch(const Ice::ConnectionManuallyClosedException& ex)
         {
             // Expected.
+            test(ex.graceful);
         }
         timeout->op(); // Ensure adapter is active.
     }
diff --git a/cpp/test/Ice/udp/AllTests.cpp b/cpp/test/Ice/udp/AllTests.cpp
index e2e00f19da2..f16b10baa70 100644
--- a/cpp/test/Ice/udp/AllTests.cpp
+++ b/cpp/test/Ice/udp/AllTests.cpp
@@ -116,7 +116,7 @@ allTests(const CommunicatorPtr& communicator)
         {
             test(seq.size() > 16384);
         }
-        obj->ice_getConnection()->close(false);
+        obj->ice_getConnection()->close(CloseGracefullyAndWait);
         communicator->getProperties()->setProperty("Ice.UDP.SndSize", "64000");
         seq.resize(50000);
         try