Merge lp:~afrantzis/mir/client-lifecycle-terminate-properly into lp:mir

[Alexandros Frantzis]

client: Fix SIGTERM dispatch in our default lifecycle event handler

Our default lifecycle event handler used to call raise() to send a TERM signal to the app when a connection break was detected. However, in a multi-threaded program raise() sends the signal to the current thread only. If the signal is blocked in that thread, then the signal is lost.

Depending on thread in which we detected that the connection was lost, the TERM signal would be dispatched (e.g. in the context of a driver callback asking for the next buffer) or not (e.g. in the context of our main RPC threads which block all signals). This MP fixes the issue by explicitly sending the signal to the process instead of the current thread. This ensures that it will be dispatched to some thread that doesn't block it.

client: Fix SIGTERM dispatch in our default lifecycle event handler

Our default lifecycle event handler used to call raise() to send a TERM signal to the app when a connection break was detected. However, in a multi-threaded program raise() sends the signal to the current thread only. If the signal is blocked in that thread, then the signal is lost.

Depending on thread in which we detected that the connection was lost, the TERM signal would be dispatched (e.g. in the context of a driver callback asking for the next buffer) or not (e.g. in the context of our main RPC threads which block all signals). This MP fixes the issue by explicitly sending the signal to the process instead of the current thread. This ensures that it will be dispatched to some thread that doesn't block it.

It turns out that we send a lifecycle connection lost event to ourselves when we release a client connection. With the signal dispatch issue fixed, this always leads to a SIGTERM being sent to the process when we call mir_connection_release() (with the default handler). This breaks most of the tests, since clients are expected to exit properly, not be terminated by a signal.

I assumed that sending a lifecycle event on release is a behavior we want, i.e. it's not accidental. If it's indeed accidental, we can remove it, along with the workaround in this MP.

The workaround proposed in this MP is for our stub client platform (used in almost all the tests that use full clients) to clear any lifecycle handlers just prior to disconnecting. This has the benefit that the default handler is active for the lifetime of the client and can therefore catch premature disconnections. It's not ideal, but it's reasonable for now (IMO).

As part of the workaround I refactored some of the test code to use newer infrastructure (like BasicClientServerFixture). However these refactorings are beneficial on their own and can remain even if we decide not to use the proposed workaround.

Finally, this change fixes some instances of the "client spinning when the server dies" issue, which is especially pronounced if we apply https://code.launchpad.net/~afrantzis/mir/fix-1347053/+merge/229221, since we won't abort() in driver code any more.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1811
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/2291/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/1171
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/1177
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/1159/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/813
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/813/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/814
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/814/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-utopic-armhf/94
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-utopic-armhf/94/artifact/work/output/*zip*/output.zip
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/2281/console
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/10857

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2291/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

1811. By Alexandros Frantzis on 2014-08-01

client: Fix SIGTERM dispatch in our default lifecycle event handler

=== modified file 'include/test/mir_test_framework/basic_client_server_fixture.h'
--- include/test/mir_test_framework/basic_client_server_fixture.h	2014-05-20 10:31:58 +0000
+++ include/test/mir_test_framework/basic_client_server_fixture.h	2014-08-01 13:50:17 +0000
@@ -22,6 +22,7 @@
 #include "mir_toolkit/mir_client_library.h"
 
 #include "mir_test_framework/in_process_server.h"
+#include "mir_test_framework/using_stub_client_platform.h"
 
 namespace mir_test_framework
 {
@@ -31,6 +32,7 @@
 struct BasicClientServerFixture : InProcessServer
 {
     TestServerConfiguration server_configuration;
+    UsingStubClientPlatform using_stub_client_platform;
 
     mir::DefaultServerConfiguration& server_config() override { return server_configuration; }
 

=== modified file 'include/test/mir_test_framework/display_server_test_fixture.h'
--- include/test/mir_test_framework/display_server_test_fixture.h	2014-04-10 22:23:27 +0000
+++ include/test/mir_test_framework/display_server_test_fixture.h	2014-08-01 13:50:17 +0000
@@ -26,6 +26,7 @@
 
 #include <memory>
 #include <functional>
+#include <vector>
 
 namespace mir_test_framework
 {
@@ -65,6 +66,7 @@
 
     bool shutdown_server_process();
     Result  wait_for_shutdown_server_process();
+    std::vector<Result> wait_for_shutdown_client_processes();
     bool kill_server_process();
     void kill_client_processes();
     void terminate_client_processes();

=== modified file 'include/test/mir_test_framework/testing_process_manager.h'
--- include/test/mir_test_framework/testing_process_manager.h	2014-04-10 22:23:27 +0000
+++ include/test/mir_test_framework/testing_process_manager.h	2014-08-01 13:50:17 +0000
@@ -27,7 +27,7 @@
 #include "mir_test_framework/testing_client_configuration.h"
 
 #include <memory>
-#include <list>
+#include <vector>
 #include <functional>
 
 namespace mir
@@ -60,13 +60,14 @@
     Result shutdown_server_process();
     Result kill_server_process();
     Result wait_for_shutdown_server_process();
+    std::vector<Result> wait_for_shutdown_client_processes();
     void kill_client_processes();
     void terminate_client_processes();
     void run_in_test_process(std::function<void()> const& run_code);
 
 private:
     std::shared_ptr<Process> server_process;
-    std::list<std::shared_ptr<Process>> clients;
+    std::vector<std::shared_ptr<Process>> clients;
 
     bool is_test_process;
     bool server_process_was_started;

=== modified file 'src/client/mir_connection.cpp'
--- src/client/mir_connection.cpp	2014-07-17 11:05:42 +0000
+++ src/client/mir_connection.cpp	2014-08-01 13:50:17 +0000
@@ -241,7 +241,12 @@
 {
     if (transition == mir_lifecycle_connection_lost)
     {
-        raise(SIGTERM);
+        /*
+         * We need to use kill() instead of raise() to ensure the signal
+         * is dispatched to the process even if it's blocked in the current
+         * thread.
+         */
+        kill(getpid(), SIGTERM);
     }
 }
 }

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2014-06-26 16:03:00 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2014-08-01 13:50:17 +0000
@@ -32,6 +32,7 @@
 #include "mir_test_framework/input_testing_server_configuration.h"
 #include "mir_test_framework/input_testing_client_configuration.h"
 #include "mir_test_framework/declarative_placement_strategy.h"
+#include "mir_test_framework/using_stub_client_platform.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -120,6 +121,7 @@
     mt::Barrier fence{2};
     mt::WaitCondition second_client_done;
     ServerConfiguration server_configuration{fence};
+    mtf::UsingStubClientPlatform using_stub_client_platform;
 
     mir::DefaultServerConfiguration& server_config() override { return server_configuration; }
 

=== modified file 'tests/acceptance-tests/test_client_screencast.cpp'
--- tests/acceptance-tests/test_client_screencast.cpp	2014-06-02 17:07:02 +0000
+++ tests/acceptance-tests/test_client_screencast.cpp	2014-08-01 13:50:17 +0000
@@ -22,8 +22,7 @@
 #include "mir_toolkit/mir_client_library.h"
 
 #include "mir_test_framework/stubbed_server_configuration.h"
-#include "mir_test_framework/in_process_server.h"
-#include "mir_test_framework/using_stub_client_platform.h"
+#include "mir_test_framework/basic_client_server_fixture.h"
 
 #include "mir_test_doubles/null_display_changer.h"
 #include "mir_test_doubles/stub_display_configuration.h"
@@ -84,15 +83,10 @@
     mtd::MockScreencast mock_screencast;
 };
 
-class MirScreencastTest : public mir_test_framework::InProcessServer
+struct MirScreencastTest : mtf::BasicClientServerFixture<StubServerConfig>
 {
-public:
-    mir::DefaultServerConfiguration& server_config() override { return server_config_; }
-
-    mtd::MockScreencast& mock_screencast() { return server_config_.mock_screencast; }
-
-    StubServerConfig server_config_;
-    mtf::UsingStubClientPlatform using_stub_client_platform;
+    mtd::MockScreencast& mock_screencast() { return server_configuration.mock_screencast; }
+
     MirScreencastParameters default_screencast_params {
         {0, 0, 1, 1}, 1, 1, mir_pixel_format_abgr_8888};
 };
@@ -111,9 +105,6 @@
 {
     using namespace testing;
 
-    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-    ASSERT_TRUE(mir_connection_is_valid(connection));
-
     mf::ScreencastSessionId const screencast_session_id{99};
 
     InSequence seq;
@@ -130,17 +121,12 @@
     auto screencast = mir_connection_create_screencast_sync(connection, &default_screencast_params);
     ASSERT_NE(nullptr, screencast);
     mir_screencast_release_sync(screencast);
-
-    mir_connection_release(connection);
 }
 
 TEST_F(MirScreencastTest, contacts_server_screencast_with_provided_params)
 {
     using namespace testing;
 
-    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-    ASSERT_TRUE(mir_connection_is_valid(connection));
-
     mf::ScreencastSessionId const screencast_session_id{99};
 
     geom::Size const size{default_screencast_params.width, default_screencast_params.height};
@@ -164,17 +150,12 @@
     ASSERT_NE(nullptr, screencast);
 
     mir_screencast_release_sync(screencast);
-
-    mir_connection_release(connection);
 }
 
 TEST_F(MirScreencastTest, creation_with_invalid_params_fails)
 {
     using namespace testing;
 
-    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-    ASSERT_TRUE(mir_connection_is_valid(connection));
-
     MirScreencastParameters params = default_screencast_params;
     params.width = params.height = 0;
     auto screencast = mir_connection_create_screencast_sync(connection, &params);
@@ -190,17 +171,12 @@
 
     screencast = mir_connection_create_screencast_sync(connection, &params);
     ASSERT_EQ(nullptr, screencast);
-
-    mir_connection_release(connection);
 }
 
 TEST_F(MirScreencastTest, gets_valid_egl_native_window)
 {
     using namespace testing;
 
-    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-    ASSERT_TRUE(mir_connection_is_valid(connection));
-
     mf::ScreencastSessionId const screencast_session_id{99};
 
     InSequence seq;
@@ -217,24 +193,17 @@
     EXPECT_NE(MirEGLNativeWindowType(), egl_native_window);
 
     mir_screencast_release_sync(screencast);
-
-    mir_connection_release(connection);
 }
 
 TEST_F(MirScreencastTest, fails_on_client_when_server_request_fails)
 {
     using namespace testing;
 
-    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-    ASSERT_TRUE(mir_connection_is_valid(connection));
-
     EXPECT_CALL(mock_screencast(), create_session(_, _, _))
         .WillOnce(Throw(std::runtime_error("")));
 
     auto screencast = mir_connection_create_screencast_sync(connection, &default_screencast_params);
     ASSERT_EQ(nullptr, screencast);
-
-    mir_connection_release(connection);
 }
 
 namespace
@@ -255,15 +224,10 @@
     MockSessionAuthorizer mock_authorizer;
 };
 
-class UnauthorizedMirScreencastTest : public mir_test_framework::InProcessServer
+struct UnauthorizedMirScreencastTest : mtf::BasicClientServerFixture<MockAuthorizerServerConfig>
 {
-public:
-    mir::DefaultServerConfiguration& server_config() override { return server_config_; }
-
-    MockSessionAuthorizer& mock_authorizer() { return server_config_.mock_authorizer; }
-
-    MockAuthorizerServerConfig server_config_;
-    mtf::UsingStubClientPlatform using_stub_client_platform;
+    MockSessionAuthorizer& mock_authorizer() { return server_configuration.mock_authorizer; }
+
     MirScreencastParameters default_screencast_params {
         {0, 0, 1, 1}, 1, 1, mir_pixel_format_abgr_8888};
 };

=== modified file 'tests/acceptance-tests/test_client_surface_swap_buffers.cpp'
--- tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2014-06-09 17:16:32 +0000
+++ tests/acceptance-tests/test_client_surface_swap_buffers.cpp	2014-08-01 13:50:17 +0000
@@ -19,8 +19,7 @@
 #include "mir_toolkit/mir_client_library.h"
 
 #include "mir_test_framework/stubbed_server_configuration.h"
-#include "mir_test_framework/in_process_server.h"
-#include "mir_test_framework/using_stub_client_platform.h"
+#include "mir_test_framework/basic_client_server_fixture.h"
 #include "mir_test_doubles/null_display_buffer_compositor_factory.h"
 #include "mir_test/signal.h"
 
@@ -43,30 +42,20 @@
     }
 };
 
-class MirSurfaceSwapBuffersTest : public mir_test_framework::InProcessServer
-{
-public:
-    mir::DefaultServerConfiguration& server_config() override { return server_config_; }
-
-    StubServerConfig server_config_;
-    mtf::UsingStubClientPlatform using_stub_client_platform;
-};
-
 void swap_buffers_callback(MirSurface*, void* ctx)
 {
     auto buffers_swapped = static_cast<mt::Signal*>(ctx);
     buffers_swapped->raise();
 }
 
+using MirSurfaceSwapBuffersTest = mtf::BasicClientServerFixture<StubServerConfig>;
+
 }
 
 TEST_F(MirSurfaceSwapBuffersTest, swap_buffers_does_not_block_when_surface_is_not_composited)
 {
     using namespace testing;
 
-    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
-    ASSERT_TRUE(mir_connection_is_valid(connection));
-
     MirSurfaceParameters request_params =
     {
         __PRETTY_FUNCTION__,
@@ -93,5 +82,4 @@
     }
 
     mir_surface_release_sync(surface);
-    mir_connection_release(connection);
 }

=== modified file 'tests/acceptance-tests/test_prompt_session_client_api.cpp'
--- tests/acceptance-tests/test_prompt_session_client_api.cpp	2014-07-21 03:35:31 +0000
+++ tests/acceptance-tests/test_prompt_session_client_api.cpp	2014-08-01 13:50:17 +0000
@@ -27,6 +27,7 @@
 #include "mir_test_doubles/stub_session_authorizer.h"
 #include "mir_test_framework/stubbed_server_configuration.h"
 #include "mir_test_framework/in_process_server.h"
+#include "mir_test_framework/using_stub_client_platform.h"
 #include "mir_test/popen.h"
 
 #include <gtest/gtest.h>
@@ -140,6 +141,7 @@
     std::shared_ptr<mf::Session> application_session;
 
     std::shared_ptr<ms::PromptSession> server_prompt_session;
+    mtf::UsingStubClientPlatform using_stub_client_platform;
 
     void SetUp() override
     {

=== modified file 'tests/acceptance-tests/test_server_disconnect.cpp'
--- tests/acceptance-tests/test_server_disconnect.cpp	2014-03-26 05:48:59 +0000
+++ tests/acceptance-tests/test_server_disconnect.cpp	2014-08-01 13:50:17 +0000
@@ -130,6 +130,40 @@
     mt::CrossProcessAction configure_display;
     mt::CrossProcessAction disconnect;
 };
+
+/*
+ * This client will self-terminate on server connection break (through the default
+ * lifecycle handler).
+ */
+struct TerminatingTestingClientConfiguration : mtf::TestingClientConfiguration
+{
+    void exec() override
+    {
+        MirConnection* connection{nullptr};
+
+        connect.exec([&] {
+            connection = mir_connect_sync(mtf::test_socket_file().c_str() , __PRETTY_FUNCTION__);
+            EXPECT_TRUE(mir_connection_is_valid(connection));
+        });
+
+        create_surface_sync.wait_for_signal_ready_for();
+
+        MirSurfaceParameters const parameters =
+        {
+            __PRETTY_FUNCTION__,
+            1, 1,
+            mir_pixel_format_abgr_8888,
+            mir_buffer_usage_hardware,
+            mir_display_output_id_invalid
+        };
+        mir_connection_create_surface_sync(connection, &parameters);
+
+        mir_connection_release(connection);
+    }
+
+    mt::CrossProcessAction connect;
+    mtf::CrossProcessSync create_surface_sync;
+};
 }
 
 TEST_F(ServerDisconnect, client_detects_server_shutdown)
@@ -168,3 +202,29 @@
         client_config.disconnect();
     });
 }
+
+TEST_F(ServerDisconnect, causes_client_to_terminate_by_default)
+{
+    TestingServerConfiguration server_config;
+    launch_server_process(server_config);
+
+    TerminatingTestingClientConfiguration client_config;
+    launch_client_process(client_config);
+
+    run_in_test_process([this, &client_config]
+    {
+        client_config.connect();
+        shutdown_server_process();
+
+        /*
+         * While trying to create a surface the connection break will be detected
+         * and the client should self-terminate.
+         */
+        client_config.create_surface_sync.signal_ready();
+
+        auto client_results = wait_for_shutdown_client_processes();
+        ASSERT_EQ(1, client_results.size());
+        EXPECT_EQ(mtf::TerminationReason::child_terminated_by_signal,
+                  client_results[0].reason);
+    });
+}

=== modified file 'tests/acceptance-tests/test_server_shutdown.cpp'
--- tests/acceptance-tests/test_server_shutdown.cpp	2014-07-21 03:35:31 +0000
+++ tests/acceptance-tests/test_server_shutdown.cpp	2014-08-01 13:50:17 +0000
@@ -327,6 +327,8 @@
 
         /* Notify the clients that we are done (we only need to set the flag once) */
         server_done.set();
+
+        wait_for_shutdown_client_processes();
     });
 
     /*

=== modified file 'tests/acceptance-tests/test_stale_frames.cpp'
--- tests/acceptance-tests/test_stale_frames.cpp	2014-07-25 10:02:18 +0000
+++ tests/acceptance-tests/test_stale_frames.cpp	2014-08-01 13:50:17 +0000
@@ -25,7 +25,6 @@
 #include "mir/graphics/buffer.h"
 #include "mir/graphics/buffer_id.h"
 
-#include "mir_test_framework/using_stub_client_platform.h"
 #include "mir_test_framework/stubbed_server_configuration.h"
 #include "mir_test_framework/basic_client_server_fixture.h"
 #include "mir_test_doubles/stub_renderer.h"
@@ -180,7 +179,6 @@
     }
 
     MirSurface* surface;
-    mtf::UsingStubClientPlatform using_stub_client_platform;
 };
 
 }

=== modified file 'tests/integration-tests/shell/test_session_lifecycle_event.cpp'
--- tests/integration-tests/shell/test_session_lifecycle_event.cpp	2014-07-21 03:35:31 +0000
+++ tests/integration-tests/shell/test_session_lifecycle_event.cpp	2014-08-01 13:50:17 +0000
@@ -19,82 +19,71 @@
 #include "mir/scene/null_session_listener.h"
 #include "src/server/scene/application_session.h"
 
-#include "mir_test_framework/display_server_test_fixture.h"
+#include "mir_test_framework/stubbed_server_configuration.h"
+#include "mir_test_framework/basic_client_server_fixture.h"
+#include "mir_test_framework/in_process_server.h"
 
 #include "mir_toolkit/mir_client_library.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
-#include <thread>
-#include <unistd.h>
-#include <fcntl.h>
-
 namespace ms = mir::scene;
-namespace msh = mir::shell;
 namespace mtf = mir_test_framework;
 
 namespace
 {
-char const* const mir_test_socket = mtf::test_socket_file().c_str();
 
 struct MockStateHandler
 {
     MOCK_METHOD1(state_changed, void (MirLifecycleState));
 };
 
+void lifecycle_callback(MirConnection* /*connection*/, MirLifecycleState state, void* context)
+{
+    auto handler = static_cast<MockStateHandler*>(context);
+    handler->state_changed(state);
+}
+
 class StubSessionListener : public ms::NullSessionListener
 {
     void stopping(std::shared_ptr<ms::Session> const& session)
     {
-        std::shared_ptr<ms::ApplicationSession> app_session(
-            std::static_pointer_cast<ms::ApplicationSession>(session)
-            );
+        auto const app_session = std::static_pointer_cast<ms::ApplicationSession>(session);
 
         app_session->set_lifecycle_state(mir_lifecycle_state_will_suspend);
     }
 };
 
-using LifecycleEventTest = BespokeDisplayServerTestFixture;
+struct StubServerConfig : mtf::StubbedServerConfiguration
+{
+    std::shared_ptr<ms::SessionListener> the_session_listener() override
+    {
+        return std::make_shared<StubSessionListener>();
+    }
+};
+
+struct LifecycleEventTest : mtf::InProcessServer
+{
+    StubServerConfig server_configuration;
+
+    mir::DefaultServerConfiguration& server_config() override
+        { return server_configuration; }
+};
+
+}
+
 TEST_F(LifecycleEventTest, lifecycle_event_test)
 {
     using namespace ::testing;
 
-    struct ServerConfig : TestingServerConfiguration
-    {
-        std::shared_ptr<ms::SessionListener> the_session_listener() override
-        {
-            return std::make_shared<StubSessionListener>();
-        }
-    } server_config;
-
-    launch_server_process(server_config);
-
-    struct ClientConfig : TestingClientConfiguration
-    {
-        static void lifecycle_callback(MirConnection* /*connection*/, MirLifecycleState state, void* context)
-        {
-            auto config = static_cast<ClientConfig*>(context);
-            config->handler->state_changed(state);
-        }
-
-        void exec()
-        {
-            handler = std::make_shared<MockStateHandler>();
-
-            MirConnection* connection = mir_connect_sync(mir_test_socket, "testapp");
-            mir_connection_set_lifecycle_event_callback(connection, lifecycle_callback, this);
-
-            EXPECT_CALL(*handler, state_changed(Eq(mir_lifecycle_state_will_suspend))).Times(1);
-            EXPECT_CALL(*handler, state_changed(Eq(mir_lifecycle_connection_lost))).Times(AtMost(1));
-            mir_connection_release(connection);
-
-            handler.reset();
-        }
-
-        std::shared_ptr<MockStateHandler> handler;
-    } client_config;
-
-    launch_client_process(client_config);
-}
+    auto const connection = mir_connect_sync(new_connection().c_str(), __PRETTY_FUNCTION__);
+
+    auto const handler = std::make_shared<MockStateHandler>();
+    mir_connection_set_lifecycle_event_callback(connection, lifecycle_callback, handler.get());
+
+    EXPECT_CALL(*handler, state_changed(Eq(mir_lifecycle_state_will_suspend))).Times(1);
+    EXPECT_CALL(*handler, state_changed(Eq(mir_lifecycle_connection_lost))).Times(AtMost(1));
+
+    mir_connection_release(connection);
 }

=== modified file 'tests/mir_test_framework/display_server_test_fixture.cpp'
--- tests/mir_test_framework/display_server_test_fixture.cpp	2014-04-10 22:23:27 +0000
+++ tests/mir_test_framework/display_server_test_fixture.cpp	2014-08-01 13:50:17 +0000
@@ -87,6 +87,11 @@
     return process_manager.wait_for_shutdown_server_process();
 }
 
+std::vector<mtf::Result> BespokeDisplayServerTestFixture::wait_for_shutdown_client_processes()
+{
+    return process_manager.wait_for_shutdown_client_processes();
+}
+
 void BespokeDisplayServerTestFixture::terminate_client_processes()
 {
     process_manager.terminate_client_processes();

=== modified file 'tests/mir_test_framework/testing_process_manager.cpp'
--- tests/mir_test_framework/testing_process_manager.cpp	2014-04-10 22:23:27 +0000
+++ tests/mir_test_framework/testing_process_manager.cpp	2014-08-01 13:50:17 +0000
@@ -203,6 +203,28 @@
     return result;
 }
 
+std::vector<mtf::Result> mtf::TestingProcessManager::wait_for_shutdown_client_processes()
+{
+    std::vector<Result> results;
+
+    if (!clients.empty())
+    {
+        for (auto client : clients)
+            results.push_back(client->wait_for_termination());
+
+        clients.clear();
+    }
+    else
+    {
+        Result result;
+        result.reason = TerminationReason::child_terminated_normally;
+        result.exit_code = EXIT_SUCCESS;
+        results.push_back(result);
+    }
+
+    return results;
+}
+
 void mtf::TestingProcessManager::terminate_client_processes()
 {
     if (is_test_process)

=== modified file 'tests/mir_test_framework/using_stub_client_platform.cpp'
--- tests/mir_test_framework/using_stub_client_platform.cpp	2014-07-29 10:25:43 +0000
+++ tests/mir_test_framework/using_stub_client_platform.cpp	2014-08-01 13:50:17 +0000
@@ -27,6 +27,10 @@
 namespace
 {
 
+void null_lifecycle_callback(MirConnection*, MirLifecycleState, void*)
+{
+}
+
 MirWaitHandle* mir_connect_override(
     char const *socket_file,
     char const *app_name,
@@ -42,6 +46,7 @@
 {
     try
     {
+        mir_connection_set_lifecycle_event_callback(connection, null_lifecycle_callback, nullptr);
         auto wait_handle = connection->disconnect();
         mir_wait_for(wait_handle);
     }

=== modified file 'tests/unit-tests/client/test_client_mir_surface.cpp'
--- tests/unit-tests/client/test_client_mir_surface.cpp	2014-07-21 03:35:31 +0000
+++ tests/unit-tests/client/test_client_mir_surface.cpp	2014-08-01 13:50:17 +0000
@@ -392,6 +392,10 @@
 {
 }
 
+void null_lifecycle_callback(MirConnection*, MirLifecycleState, void*)
+{
+}
+
 MATCHER_P(BufferPackageMatches, package, "")
 {
     // Can't simply use memcmp() on the whole struct because age is not sent over the wire
@@ -415,6 +419,13 @@
         connect_to_test_server();
     }
 
+    ~MirClientSurfaceTest()
+    {
+        // Clear the lifecycle callback in order not to get SIGTERM by the default
+        // lifecycle handler during connection teardown
+        connection->register_lifecycle_event_callback(null_lifecycle_callback, nullptr);
+    }
+
     void start_test_server()
     {
         // In case an earlier test left a stray file