Merge lp:~robertcarr/mir/refactor-input-acceptance-take-1 into lp:mir

[Robert Carr]

Some cleanups to test_client_input.cpp

First take at simplifying input acceptance tests with a better shared fixture.

Merged client-input-report to debug an issue, so hopefully we can merge this after.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1205
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~robertcarr/mir/refactor-input-acceptance-take-1/+merge/194265/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/347/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/139
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/136/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/76/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/76
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/76/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/mir-team-mir-development-branch-ci/347/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1206
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/351/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/146
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/143
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/80
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/80/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/80
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/80/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/mir-team-mir-development-branch-ci/351/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1207
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/356/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-trusty-i386-build/151
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-trusty-amd64-build/148
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/85
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-amd64-ci/85/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/85
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-trusty-armhf-ci/85/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://10.97.0.26:8080/job/mir-team-mir-development-branch-ci/356/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Looks sane in general. I am not familiar enough with the functionality to be sure everything is covered adequately.

review: Approve

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

[Robert Carr (robertcarr)]

The tests are basically identical. Mostly about.

1. Removing some dead code (wait_until_client_appears, etc).
2. Factoring out highly repetitive code: i.e. this sort of stuff
918 - struct ServerConfiguration : mtf::InputTestingServerConfiguration
919 - {
920 - mtf::CrossProcessSync input_cb_setup_fence;
921 -
922 - ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence)
923 - : input_cb_setup_fence(input_cb_setup_fence)
--------------
0 - void inject_input()
301 - {
302 - wait_until_client_appears(test_client_name);
303 - input_cb_setup_fence.wait_for_signal_ready_for();
304 -

309 - } server_config(fence);
310 - launch_server_process(server_config);
-------------
311 -
312 - struct KeyReceivingClient : InputClient
313 - {
314 - KeyReceivingClient(const mtf::CrossProcessSync& fence) : InputClient(fence, test_client_name) {}
3. Removing some noise from the file, i.e. client_event_matchers.h

I can't quite see the end yet so am trying to make small improvements like this, but would eventually like to get to something super succint:
mtf::InputReceivingClient client;
client.expects_input(mis::a_button_down_event()).expects_input(mis::a_button_up_event()).exits();

=== added file 'include/test/mir_test/client_event_matchers.h'
--- include/test/mir_test/client_event_matchers.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test/client_event_matchers.h	2013-11-07 17:24:53 +0000
@@ -0,0 +1,119 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "mir_toolkit/event.h"
+
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-keysyms.h>
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+
+MATCHER(KeyDownEvent, "")
+{
+    if (arg->type != mir_event_type_key)
+        return false;
+    if (arg->key.action != mir_key_action_down) // Key down
+        return false;
+
+    return true;
+}
+MATCHER_P(KeyOfSymbol, keysym, "")
+{
+    if (static_cast<xkb_keysym_t>(arg->key.key_code) == (uint)keysym)
+        return true;
+    return false;
+}
+
+MATCHER(HoverEnterEvent, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_hover_enter)
+        return false;
+
+    return true;
+}
+MATCHER(HoverExitEvent, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_hover_exit)
+        return false;
+
+    return true;
+}
+
+MATCHER_P2(ButtonDownEvent, x, y, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_down)
+        return false;
+    if (arg->motion.button_state == 0)
+        return false;
+    if (arg->motion.pointer_coordinates[0].x != x)
+        return false;
+    if (arg->motion.pointer_coordinates[0].y != y)
+        return false;
+    return true;
+}
+
+MATCHER_P2(ButtonUpEvent, x, y, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_up)
+        return false;
+    if (arg->motion.pointer_coordinates[0].x != x)
+        return false;
+    if (arg->motion.pointer_coordinates[0].y != y)
+        return false;
+    return true;
+}
+
+MATCHER_P2(MotionEventWithPosition, x, y, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_move &&
+        arg->motion.action != mir_motion_action_hover_move)
+        return false;
+    if (arg->motion.pointer_coordinates[0].x != x)
+        return false;
+    if (arg->motion.pointer_coordinates[0].y != y)
+        return false;
+    return true;
+}
+
+MATCHER(MovementEvent, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_move &&
+        arg->motion.action != mir_motion_action_hover_move)
+        return false;
+    return true;
+}
+
+}
+}
 
=== modified file 'include/test/mir_test_framework/input_testing_server_configuration.h'
--- include/test/mir_test_framework/input_testing_server_configuration.h	2013-08-28 03:41:48 +0000
+++ include/test/mir_test_framework/input_testing_server_configuration.h	2013-11-07 17:24:53 +0000
@@ -52,8 +52,6 @@
 namespace mir_test_framework
 {
 
-enum ClientLifecycleState { starting, appeared, vanished };
-
 class InputTestingServerConfiguration : public TestingServerConfiguration
 {
 public:
@@ -63,24 +61,18 @@
     void on_exit();
     
     std::shared_ptr<mir::input::InputConfiguration> the_input_configuration() override;
-    std::shared_ptr<mir::frontend::Shell> the_frontend_shell() override;
+
+    mir::input::android::FakeEventHub* fake_event_hub;
 
 protected:
     virtual void inject_input() = 0;
-    mir::input::android::FakeEventHub* fake_event_hub;
 
     void wait_until_client_appears(std::string const& surface_name);
 
 private:
-    std::mutex lifecycle_lock;
-
-    std::condition_variable lifecycle_condition;
-    std::map<std::string, ClientLifecycleState> client_lifecycles;
-    
     std::thread input_injection_thread;
     
     std::shared_ptr<mir::test::doubles::FakeEventHubInputConfiguration> input_configuration;
-    std::shared_ptr<mir::frontend::Shell> frontend_shell;
 };
 
 }
 
=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-10-28 21:41:27 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-11-07 17:24:53 +0000
@@ -35,6 +35,7 @@
 #include "mir_test/fake_event_hub.h"
 #include "mir_test/event_factory.h"
 #include "mir_test/wait_condition.h"
+#include "mir_test/client_event_matchers.h"
 #include "mir_test_framework/cross_process_sync.h"
 #include "mir_test_framework/display_server_test_fixture.h"
 #include "mir_test_framework/input_testing_server_configuration.h"
@@ -42,9 +43,6 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
-#include <xkbcommon/xkbcommon.h>
-#include <xkbcommon/xkbcommon-keysyms.h>
-
 #include <thread>
 #include <functional>
 #include <map>
@@ -213,281 +211,6 @@
     static int const surface_height = 100;
 };
 
-MATCHER(KeyDownEvent, "")
-{
-    if (arg->type != mir_event_type_key)
-        return false;
-    if (arg->key.action != mir_key_action_down) // Key down
-        return false;
-
-    return true;
-}
-MATCHER_P(KeyOfSymbol, keysym, "")
-{
-    if (static_cast<xkb_keysym_t>(arg->key.key_code) == (uint)keysym)
-        return true;
-    return false;
-}
-
-MATCHER(HoverEnterEvent, "")
-{
-    if (arg->type != mir_event_type_motion)
-        return false;
-    if (arg->motion.action != mir_motion_action_hover_enter)
-        return false;
-
-    return true;
-}
-MATCHER(HoverExitEvent, "")
-{
-    if (arg->type != mir_event_type_motion)
-        return false;
-    if (arg->motion.action != mir_motion_action_hover_exit)
-        return false;
-
-    return true;
-}
-
-MATCHER_P2(ButtonDownEvent, x, y, "")
-{
-    if (arg->type != mir_event_type_motion)
-        return false;
-    if (arg->motion.action != mir_motion_action_down)
-        return false;
-    if (arg->motion.button_state == 0)
-        return false;
-    if (arg->motion.pointer_coordinates[0].x != x)
-        return false;
-    if (arg->motion.pointer_coordinates[0].y != y)
-        return false;
-    return true;
-}
-
-MATCHER_P2(ButtonUpEvent, x, y, "")
-{
-    if (arg->type != mir_event_type_motion)
-        return false;
-    if (arg->motion.action != mir_motion_action_up)
-        return false;
-    if (arg->motion.pointer_coordinates[0].x != x)
-        return false;
-    if (arg->motion.pointer_coordinates[0].y != y)
-        return false;
-    return true;
-}
-
-MATCHER_P2(MotionEventWithPosition, x, y, "")
-{
-    if (arg->type != mir_event_type_motion)
-        return false;
-    if (arg->motion.action != mir_motion_action_move &&
-        arg->motion.action != mir_motion_action_hover_move)
-        return false;
-    if (arg->motion.pointer_coordinates[0].x != x)
-        return false;
-    if (arg->motion.pointer_coordinates[0].y != y)
-        return false;
-    return true;
-}
-
-MATCHER(MovementEvent, "")
-{
-    if (arg->type != mir_event_type_motion)
-        return false;
-    if (arg->motion.action != mir_motion_action_move &&
-        arg->motion.action != mir_motion_action_hover_move)
-        return false;
-    return true;
-}
-
-}
-
-
-using TestClientInput = BespokeDisplayServerTestFixture;
-
-TEST_F(TestClientInput, clients_receive_key_input)
-{
-    using namespace ::testing;
-    
-    int const num_events_produced = 3;
-    static std::string const test_client_name = "1";
-
-    mtf::CrossProcessSync fence;
-
-    struct ServerConfiguration : mtf::InputTestingServerConfiguration
-    {
-        mtf::CrossProcessSync input_cb_setup_fence;
-
-        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
-                : input_cb_setup_fence(input_cb_setup_fence)
-        {
-        }
-        
-        void inject_input()
-        {
-            wait_until_client_appears(test_client_name);
-            input_cb_setup_fence.wait_for_signal_ready_for();
-
-            for (int i = 0; i < num_events_produced; i++)
-                fake_event_hub->synthesize_event(mis::a_key_down_event()
-                                                 .of_scancode(KEY_ENTER));
-        }
-    } server_config(fence);
-    launch_server_process(server_config);
-    
-    struct KeyReceivingClient : InputClient
-    {
-        KeyReceivingClient(const mtf::CrossProcessSync& fence) : InputClient(fence, test_client_name) {}
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            using namespace ::testing;
-            InSequence seq;
-
-            EXPECT_CALL(*handler, handle_input(KeyDownEvent())).Times(2);
-            EXPECT_CALL(*handler, handle_input(KeyDownEvent())).Times(1)
-                .WillOnce(mt::WakeUp(&events_received));
-        }
-    } client_config(fence);
-    launch_client_process(client_config);
-}
-
-TEST_F(TestClientInput, clients_receive_us_english_mapped_keys)
-{
-    using namespace ::testing;
-    static std::string const test_client_name = "1";
-    mtf::CrossProcessSync fence;
-
-    struct ServerConfiguration : mtf::InputTestingServerConfiguration
-    {
-        mtf::CrossProcessSync input_cb_setup_fence;
-
-        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
-                : input_cb_setup_fence(input_cb_setup_fence)
-        {
-        }
-
-        void inject_input()
-        {
-            wait_until_client_appears(test_client_name);
-            input_cb_setup_fence.wait_for_signal_ready_for();
-
-            fake_event_hub->synthesize_event(mis::a_key_down_event()
-                                             .of_scancode(KEY_LEFTSHIFT));
-            fake_event_hub->synthesize_event(mis::a_key_down_event()
-                                             .of_scancode(KEY_4));
-
-        }
-    } server_config{fence};
-    launch_server_process(server_config);
-    
-    struct KeyReceivingClient : InputClient
-    {
-        KeyReceivingClient(const mtf::CrossProcessSync& fence) : InputClient(fence, test_client_name) {}
-
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            using namespace ::testing;
-
-            InSequence seq;
-            EXPECT_CALL(*handler, handle_input(AllOf(KeyDownEvent(), KeyOfSymbol(XKB_KEY_Shift_L)))).Times(1);
-            EXPECT_CALL(*handler, handle_input(AllOf(KeyDownEvent(), KeyOfSymbol(XKB_KEY_dollar)))).Times(1)
-                .WillOnce(mt::WakeUp(&events_received));
-        }
-    } client_config{fence};
-    launch_client_process(client_config);
-}
-
-TEST_F(TestClientInput, clients_receive_motion_inside_window)
-{
-    using namespace ::testing;
-    static std::string const test_client_name = "1";
-    mtf::CrossProcessSync fence;
-
-    struct ServerConfiguration : public mtf::InputTestingServerConfiguration
-    {
-        mtf::CrossProcessSync input_cb_setup_fence;
-
-        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
-                : input_cb_setup_fence(input_cb_setup_fence)
-        {
-        }
-
-        void inject_input()
-        {
-            wait_until_client_appears(test_client_name);
-            input_cb_setup_fence.wait_for_signal_ready_for();
-
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(InputClient::surface_width - 1,
-                                                                                 InputClient::surface_height - 1));
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(2,2));
-        }
-    } server_config{fence};
-    launch_server_process(server_config);
-    
-    struct MotionReceivingClient : InputClient
-    {
-        MotionReceivingClient(const mtf::CrossProcessSync& fence) : InputClient(fence, test_client_name) {}
-
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            using namespace ::testing;
-            
-            InSequence seq;
-
-            // We should see the cursor enter
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1);
-            EXPECT_CALL(*handler, handle_input(
-                MotionEventWithPosition(InputClient::surface_width - 1,
-                                        InputClient::surface_height - 1))).Times(1)
-                .WillOnce(mt::WakeUp(&events_received));
-            // But we should not receive an event for the second movement outside of our surface!
-        }
-    } client_config{fence};
-    launch_client_process(client_config);
-}
-
-TEST_F(TestClientInput, clients_receive_button_events_inside_window)
-{
-    using namespace ::testing;
-    
-    static std::string const test_client_name = "1";
-    mtf::CrossProcessSync fence;
-
-    struct ServerConfiguration : public mtf::InputTestingServerConfiguration
-    {
-        mtf::CrossProcessSync input_cb_setup_fence;
-
-        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
-                : input_cb_setup_fence(input_cb_setup_fence)
-        {
-        }
-
-        void inject_input()
-        {
-            wait_until_client_appears(test_client_name);
-            input_cb_setup_fence.wait_for_signal_ready_for();
-
-            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
-        }
-    } server_config{fence};
-    launch_server_process(server_config);
-    
-    struct ButtonReceivingClient : InputClient
-    {
-        ButtonReceivingClient(const mtf::CrossProcessSync& fence) : InputClient(fence, test_client_name) {}
-
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            using namespace ::testing;
-            
-            InSequence seq;
-
-            // The cursor starts at (0, 0).
-            EXPECT_CALL(*handler, handle_input(ButtonDownEvent(0, 0))).Times(1)
-                .WillOnce(mt::WakeUp(&events_received));
-        }
-    } client_config{fence};
-    launch_client_process(client_config);
 }
 
 namespace
@@ -497,34 +220,251 @@
 
 struct StaticPlacementStrategy : public msh::PlacementStrategy
 {
-    StaticPlacementStrategy(GeometryMap const& positions,
+    StaticPlacementStrategy(std::shared_ptr<msh::PlacementStrategy> const& underlying_strategy,
+                            GeometryMap const& positions,
                             DepthMap const& depths)
-        : surface_geometry_by_name(positions),
+        : underlying_strategy(underlying_strategy),
+          surface_geometry_by_name(positions),
           surface_depths_by_name(depths)
     {
     }
 
-    StaticPlacementStrategy(GeometryMap const& positions)
-        : StaticPlacementStrategy(positions, DepthMap())
+    StaticPlacementStrategy(std::shared_ptr<msh::PlacementStrategy> const& underlying_strategy,
+                            GeometryMap const& positions)
+        : StaticPlacementStrategy(underlying_strategy, positions, DepthMap())
     {
     }
 
-    msh::SurfaceCreationParameters place(msh::Session const&, msh::SurfaceCreationParameters const& request_parameters)
+    msh::SurfaceCreationParameters place(msh::Session const& session, msh::SurfaceCreationParameters const& request_parameters)
     {
         auto placed = request_parameters;
         auto const& name = request_parameters.name;
-        auto geometry = surface_geometry_by_name[name];
-
-        placed.top_left = geometry.top_left;
-        placed.size = geometry.size;
+        
+        auto it = surface_geometry_by_name.find(name);
+        if (it != surface_geometry_by_name.end())
+        {
+            auto const& geometry = it->second;
+            placed.top_left = geometry.top_left;
+            placed.size = geometry.size;
+        }
+        else
+        {
+            placed = underlying_strategy->place(session, placed);
+        }
         placed.depth = surface_depths_by_name[name];
         
         return placed;
     }
+    
+    std::shared_ptr<msh::PlacementStrategy> const underlying_strategy;
     GeometryMap surface_geometry_by_name;
     DepthMap surface_depths_by_name;
 };
 
+std::shared_ptr<mtf::InputTestingServerConfiguration>
+make_event_producing_server(mtf::CrossProcessSync const& client_ready_fence, 
+    int number_of_clients,
+    std::function<void(mtf::InputTestingServerConfiguration& server)> const& produce_events,
+    GeometryMap const& client_geometry_map, DepthMap const& client_depth_map)
+{
+    struct ServerConfiguration : mtf::InputTestingServerConfiguration
+    {
+        mtf::CrossProcessSync input_cb_setup_fence;
+        int const number_of_clients;
+        std::function<void(mtf::InputTestingServerConfiguration& server)> const produce_events;
+        GeometryMap const client_geometry;
+        DepthMap const client_depth;
+
+        ServerConfiguration(mtf::CrossProcessSync const& input_cb_setup_fence, int number_of_clients,
+                            std::function<void(mtf::InputTestingServerConfiguration& server)> const& produce_events,
+                            GeometryMap const& client_geometry, DepthMap const& client_depth) 
+                : input_cb_setup_fence(input_cb_setup_fence),
+                  number_of_clients(number_of_clients),
+                  produce_events(produce_events),
+                  client_geometry(client_geometry),
+                  client_depth(client_depth)
+        {
+        }
+        
+        std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override
+        {
+            return std::make_shared<StaticPlacementStrategy>(InputTestingServerConfiguration::the_shell_placement_strategy(),
+                client_geometry, client_depth);
+        }
+        
+        void inject_input()
+        {
+            for (int i = 1; i < number_of_clients + 1; i++)
+                EXPECT_EQ(i, input_cb_setup_fence.wait_for_signal_ready_for());
+            produce_events(*this);
+        }
+    };
+    return std::make_shared<ServerConfiguration>(client_ready_fence, number_of_clients,
+        produce_events, client_geometry_map, client_depth_map);
+}
+
+std::shared_ptr<mtf::InputTestingServerConfiguration>
+make_event_producing_server(mtf::CrossProcessSync const& client_ready_fence, int number_of_clients,
+                            std::function<void(mtf::InputTestingServerConfiguration& server)> const& produce_events)
+{
+    return make_event_producing_server(client_ready_fence, number_of_clients,
+        produce_events, GeometryMap(), DepthMap());
+}
+
+std::shared_ptr<InputClient>
+make_event_expecting_client(std::string const& client_name, mtf::CrossProcessSync const& client_ready_fence,
+                            std::function<void(MockInputHandler &, mt::WaitCondition&)> const& expect_input)
+{
+    struct EventReceivingClient : InputClient
+    {
+        std::function<void(MockInputHandler&, mt::WaitCondition&)> const expect_cb;
+
+        EventReceivingClient(mtf::CrossProcessSync const& client_ready_fence, std::string const& client_name,
+                             std::function<void(MockInputHandler&, mt::WaitCondition&)> const& expect_cb)
+            : InputClient(client_ready_fence, client_name),
+              expect_cb(expect_cb)
+        {
+        }
+        void expect_input(mt::WaitCondition& events_received) override
+        {
+            expect_cb(*handler, events_received);
+        }
+    };
+    return std::make_shared<EventReceivingClient>(client_ready_fence, client_name, expect_input);
+}
+
+std::shared_ptr<InputClient>
+make_event_expecting_client(mtf::CrossProcessSync const& client_ready_fence,
+                            std::function<void(MockInputHandler &, mt::WaitCondition&)> const& expect_input)
+{
+    return make_event_expecting_client("input-test-client", client_ready_fence, expect_input);
+}
+
+}
+
+
+using TestClientInput = BespokeDisplayServerTestFixture;
+
+TEST_F(TestClientInput, clients_receive_key_input)
+{
+    using namespace ::testing;
+    
+    static std::string const test_client_name = "1";
+
+    mtf::CrossProcessSync fence;
+
+    auto server_config = make_event_producing_server(fence, 1,
+         [&](mtf::InputTestingServerConfiguration& server)
+         {
+             int const num_events_produced = 3;
+
+             for (int i = 0; i < num_events_produced; i++)
+                 server.fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                                         .of_scancode(KEY_ENTER));
+         });
+    launch_server_process(*server_config);
+    
+    auto client_config = make_event_expecting_client(fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            using namespace ::testing;
+            InSequence seq;
+
+            EXPECT_CALL(handler, handle_input(mt::KeyDownEvent())).Times(2);
+            EXPECT_CALL(handler, handle_input(mt::KeyDownEvent())).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+
+         });
+    launch_client_process(*client_config);
+}
+
+TEST_F(TestClientInput, clients_receive_us_english_mapped_keys)
+{
+    using namespace ::testing;
+    static std::string const test_client_name = "1";
+    mtf::CrossProcessSync fence;
+
+    auto server_config = make_event_producing_server(fence, 1,
+         [&](mtf::InputTestingServerConfiguration& server)
+         {
+            server.fake_event_hub->synthesize_event(mis::a_key_down_event()
+                .of_scancode(KEY_LEFTSHIFT));
+            server.fake_event_hub->synthesize_event(mis::a_key_down_event()
+                .of_scancode(KEY_4));
+        });
+    launch_server_process(*server_config);
+
+    auto client_config = make_event_expecting_client(fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            using namespace ::testing;
+            InSequence seq;
+    
+            EXPECT_CALL(handler, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_Shift_L)))).Times(1);
+            EXPECT_CALL(handler, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_dollar)))).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+        });
+    launch_client_process(*client_config);
+}
+
+TEST_F(TestClientInput, clients_receive_motion_inside_window)
+{
+    using namespace ::testing;
+    static std::string const test_client_name = "1";
+    mtf::CrossProcessSync fence;
+    
+    auto server_config = make_event_producing_server(fence, 1,
+         [&](mtf::InputTestingServerConfiguration& server)
+         {
+             server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(InputClient::surface_width - 1,
+                 InputClient::surface_height - 1));
+             server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(2,2));
+        });
+    launch_server_process(*server_config);
+    
+    auto client_config = make_event_expecting_client(fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            using namespace ::testing;
+            InSequence seq;
+
+            // We should see the cursor enter
+            EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(1);
+            EXPECT_CALL(handler, handle_input(
+                mt::MotionEventWithPosition(InputClient::surface_width - 1,
+                                        InputClient::surface_height - 1))).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+            // But we should not receive an event for the second movement outside of our surface!
+         });
+    launch_client_process(*client_config);
+}
+
+TEST_F(TestClientInput, clients_receive_button_events_inside_window)
+{
+    using namespace ::testing;
+    
+    static std::string const test_client_name = "1";
+    mtf::CrossProcessSync fence;
+
+    auto server_config = make_event_producing_server(fence, 1,
+         [&](mtf::InputTestingServerConfiguration& server)
+         {
+             server.fake_event_hub->synthesize_event(mis::a_button_down_event()
+                 .of_button(BTN_LEFT).with_action(mis::EventAction::Down));
+         });
+    launch_server_process(*server_config);
+
+    auto client_config = make_event_expecting_client(fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            using namespace ::testing;
+            InSequence seq;
+            
+            // The cursor starts at (0, 0).
+            EXPECT_CALL(handler, handle_input(mt::ButtonDownEvent(0, 0))).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+        });
+    launch_client_process(*client_config);
 }
 
 TEST_F(TestClientInput, multiple_clients_receive_motion_inside_windows)
@@ -539,77 +479,42 @@
     static std::string const test_client_2 = "2";
     mtf::CrossProcessSync fence;
 
-    struct ServerConfiguration : mtf::InputTestingServerConfiguration
-    {
-        mtf::CrossProcessSync input_cb_setup_fence;
-
-        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
-                : input_cb_setup_fence(input_cb_setup_fence)
-        {
-        }
-
-        std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override
-        {
-            static GeometryMap positions;
-            positions[test_client_1] = geom::Rectangle{geom::Point{0, 0},
-                geom::Size{client_width, client_height}};
-            positions[test_client_2] = geom::Rectangle{geom::Point{screen_width/2, screen_height/2},
-                geom::Size{client_width, client_height}};
-
-            return std::make_shared<StaticPlacementStrategy>(positions);
-        }
-        
-        void inject_input() override
-        {
-            wait_until_client_appears(test_client_1);
-            EXPECT_EQ(1, input_cb_setup_fence.wait_for_signal_ready_for());
-            wait_until_client_appears(test_client_2);
-            EXPECT_EQ(2, input_cb_setup_fence.wait_for_signal_ready_for());
-
+    static GeometryMap positions;
+    positions[test_client_1] = geom::Rectangle{geom::Point{0, 0},
+                                               geom::Size{client_width, client_height}};
+    positions[test_client_2] = geom::Rectangle{geom::Point{screen_width/2, screen_height/2},
+                                               geom::Size{client_width, client_height}};
+
+    auto server_config = make_event_producing_server(fence, 2,
+         [&](mtf::InputTestingServerConfiguration& server)
+         {
             // In the bounds of the first surface
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2-1, screen_height/2-1));
+            server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2-1, screen_height/2-1));
             // In the bounds of the second surface
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2, screen_height/2));
-        }
-    } server_config{fence};
-    
-    launch_server_process(server_config);
-    
-    struct InputClientOne : InputClient
-    {
-        InputClientOne(const mtf::CrossProcessSync& fence)
-                : InputClient(fence, test_client_1)
-        {
-        }
-        
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            InSequence seq;
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1);
-            EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(client_width - 1, client_height - 1))).Times(1);
-            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(1)
-                .WillOnce(mt::WakeUp(&events_received));
-        }
-    } client_1{fence};
-
-    struct InputClientTwo : InputClient
-    {
-        InputClientTwo(const mtf::CrossProcessSync& fence)
-                : InputClient(fence, test_client_2)
-        {
-        }
-        
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            InSequence seq;
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1);
-            EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(client_width - 1, client_height - 1))).Times(1)
-                .WillOnce(mt::WakeUp(&events_received));
-        }
-    } client_2{fence};
-
-    launch_client_process(client_1);
-    launch_client_process(client_2);
+            server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2, screen_height/2));
+        }, positions, DepthMap());
+    launch_server_process(*server_config);
+
+    auto client_1 = make_event_expecting_client(test_client_1, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            InSequence seq;
+            EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(1);
+            EXPECT_CALL(handler, handle_input(mt::MotionEventWithPosition(client_width - 1, client_height - 1))).Times(1);
+            EXPECT_CALL(handler, handle_input(mt::HoverExitEvent())).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+        });
+    auto client_2 = make_event_expecting_client(test_client_2, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+             InSequence seq;
+             EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(1);
+             EXPECT_CALL(handler, handle_input(mt::MotionEventWithPosition(client_width - 1, client_height - 1))).Times(1)
+                 .WillOnce(mt::WakeUp(&events_received));
+        });
+
+    launch_client_process(*client_1);
+    launch_client_process(*client_2);
 }
 
 namespace
@@ -639,6 +544,7 @@
     std::vector<geom::Rectangle> const input_rectangles;
 };
 }
+
 TEST_F(TestClientInput, clients_do_not_receive_motion_outside_input_region)
 {
     using namespace ::testing;
@@ -670,7 +576,7 @@
             static GeometryMap positions;
             positions[test_client_name] = screen_geometry;
             
-            return std::make_shared<StaticPlacementStrategy>(positions);
+            return std::make_shared<StaticPlacementStrategy>(InputTestingServerConfiguration::the_shell_placement_strategy(), positions);
         }
         std::shared_ptr<msh::SurfaceFactory> the_shell_surface_factory() override
         {
@@ -680,7 +586,6 @@
         
         void inject_input() override
         {
-            wait_until_client_appears(test_client_name);
             input_cb_setup_fence.wait_for_signal_ready_for();
             
             // First we will move the cursor in to the input region on the left side of the window. We should see a click here
@@ -697,35 +602,26 @@
             fake_event_hub->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
         }
     } server_config{fence};
-    
     launch_server_process(server_config);
 
-    struct ClientConfig : InputClient
-    {
-        ClientConfig(const mtf::CrossProcessSync& fence)
-                : InputClient(fence, test_client_name)
-        {
-        }
-
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(MovementEvent())).Times(AnyNumber());
+    auto client_config = make_event_expecting_client(test_client_name, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::MovementEvent())).Times(AnyNumber());
 
             {
                 // We should see two of the three button pairs.
                 InSequence seq;
-                EXPECT_CALL(*handler, handle_input(ButtonDownEvent(1, 1))).Times(1);
-                EXPECT_CALL(*handler, handle_input(ButtonUpEvent(1, 1))).Times(1);
-                EXPECT_CALL(*handler, handle_input(ButtonDownEvent(99, 99))).Times(1);
-                EXPECT_CALL(*handler, handle_input(ButtonUpEvent(99, 99))).Times(1)
+                EXPECT_CALL(handler, handle_input(mt::ButtonDownEvent(1, 1))).Times(1);
+                EXPECT_CALL(handler, handle_input(mt::ButtonUpEvent(1, 1))).Times(1);
+                EXPECT_CALL(handler, handle_input(mt::ButtonDownEvent(99, 99))).Times(1);
+                EXPECT_CALL(handler, handle_input(mt::ButtonUpEvent(99, 99))).Times(1)
                     .WillOnce(mt::WakeUp(&events_received));
             }
-        }
-    } client_config{fence};
-    launch_client_process(client_config);
+        });
+    launch_client_process(*client_config);
 }
 
 TEST_F(TestClientInput, surfaces_obscure_motion_events_by_stacking)
@@ -742,98 +638,62 @@
     static geom::Rectangle const screen_geometry{geom::Point{0, 0},
         geom::Size{screen_width, screen_height}};
 
-    struct ServerConfiguration : mtf::InputTestingServerConfiguration
-    {
-        mtf::CrossProcessSync input_cb_setup_fence;
-
-        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
-                : input_cb_setup_fence(input_cb_setup_fence)
-        {
-        }
-
-        std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override
-        {
-            static GeometryMap positions;
-            positions[test_client_name_1] = screen_geometry;
-            
-            auto smaller_geometry = screen_geometry;
-            smaller_geometry.size.width = geom::Width{screen_width/2};
-            positions[test_client_name_2] = smaller_geometry;
-            
-            static DepthMap depths;
-            depths[test_client_name_1] = ms::DepthId{0};
-            depths[test_client_name_2] = ms::DepthId{1};
-            
-            return std::make_shared<StaticPlacementStrategy>(positions, depths);
-        }
-        
-        void inject_input() override
-        {
-            wait_until_client_appears(test_client_name_1);
-            input_cb_setup_fence.wait_for_signal_ready_for();
-            wait_until_client_appears(test_client_name_2);
-            input_cb_setup_fence.wait_for_signal_ready_for();
-
+    static GeometryMap positions;
+    positions[test_client_name_1] = screen_geometry;
+            
+    auto smaller_geometry = screen_geometry;
+    smaller_geometry.size.width = geom::Width{screen_width/2};
+    positions[test_client_name_2] = smaller_geometry;
+            
+    static DepthMap depths;
+    depths[test_client_name_1] = ms::DepthId{0};
+    depths[test_client_name_2] = ms::DepthId{1};
+    
+    auto server_config = make_event_producing_server(fence, 2,
+        [&](mtf::InputTestingServerConfiguration& server)
+        {
             // First we will move the cursor in to the region where client 2 obscures client 1
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 1));
-            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
-            fake_event_hub->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
+            server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1, 1));
+            server.fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
+            server.fake_event_hub->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
             // Now we move to the unobscured region of client 1
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(50, 0));
-            fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
-            fake_event_hub->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
-        }
-    } server_config{fence};
-    
-    launch_server_process(server_config);
-
-    struct ClientConfigOne : InputClient
-    {
-        ClientConfigOne(const mtf::CrossProcessSync& fence)
-                : InputClient(fence, test_client_name_1)
-        {
-        }
-
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(MovementEvent())).Times(AnyNumber());
-
+            server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(50, 0));
+            server.fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
+            server.fake_event_hub->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
+        }, positions, depths);
+    launch_server_process(*server_config);
+
+    auto client_config_1 = make_event_expecting_client(test_client_name_1, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::MovementEvent())).Times(AnyNumber());
             {
                 // We should only see one button event sequence.
                 InSequence seq;
-                EXPECT_CALL(*handler, handle_input(ButtonDownEvent(51, 1))).Times(1);
-                EXPECT_CALL(*handler, handle_input(ButtonUpEvent(51, 1))).Times(1)
+                EXPECT_CALL(handler, handle_input(mt::ButtonDownEvent(51, 1))).Times(1);
+                EXPECT_CALL(handler, handle_input(mt::ButtonUpEvent(51, 1))).Times(1)
                     .WillOnce(mt::WakeUp(&events_received));
             }
-        }
-    } client_config_1{fence};
-    launch_client_process(client_config_1);
-
-    struct ClientConfigTwo : InputClient
-    {
-        ClientConfigTwo(const mtf::CrossProcessSync& fence)
-                : InputClient(fence, test_client_name_2)
-        {
-        }
-
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(MovementEvent())).Times(AnyNumber());
-
+        });
+    auto client_config_2 = make_event_expecting_client(test_client_name_2, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::MovementEvent())).Times(AnyNumber());
             {
                 // Likewise we should only see one button sequence.
               InSequence seq;
-              EXPECT_CALL(*handler, handle_input(ButtonDownEvent(1, 1))).Times(1);
-              EXPECT_CALL(*handler, handle_input(ButtonUpEvent(1, 1))).Times(1)
+              EXPECT_CALL(handler, handle_input(mt::ButtonDownEvent(1, 1))).Times(1);
+              EXPECT_CALL(handler, handle_input(mt::ButtonUpEvent(1, 1))).Times(1)
                   .WillOnce(mt::WakeUp(&events_received));
             }
-        }
-    } client_config_2{fence};
-    launch_client_process(client_config_2);
+        });
+    
+    launch_client_process(*client_config_1);
+    launch_client_process(*client_config_2);
 }
 
 namespace
@@ -853,93 +713,48 @@
     static std::string const test_client_name = "1";
     static std::string const test_client_2_name = "2";
     mtf::CrossProcessSync fence, first_client_ready_fence, second_client_done_fence;
-
-    struct ServerConfiguration : public mtf::InputTestingServerConfiguration
-    {
-        mtf::CrossProcessSync input_cb_setup_fence;
-        mtf::CrossProcessSync second_client_done_fence;
-
-        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence,
-                            const mtf::CrossProcessSync& second_client_done_fence) 
-                : input_cb_setup_fence(input_cb_setup_fence),
-                  second_client_done_fence(second_client_done_fence)
-        {
-        }
-        
-        void hide_session_by_name(std::string const& session_name)
-        {
-            the_shell_session_container()->for_each([&](std::shared_ptr<msh::Session> const& session) -> void
-            {
-                if (session->name() == session_name)
-                    session->hide();
-            });
-        }
-
-        void inject_input()
-        {
-            wait_until_client_appears(test_client_name);
-            wait_until_client_appears(test_client_2_name);
-            input_cb_setup_fence.wait_for_signal_ready_for();
-
+    
+    static DepthMap depths;
+    depths[test_client_name] = ms::DepthId{0};
+    depths[test_client_2_name] = ms::DepthId{1};
+
+    auto server_config = make_event_producing_server(fence, 2,
+        [&](mtf::InputTestingServerConfiguration& server)
+        {
             // We send one event and then hide the surface on top before sending the next. 
-            // So we expect each of the two surfaces to receive one event pair.
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1,1));
-
+            // So we expect each of the two surfaces to receive one even
+            server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1,1));
             // We use a fence to ensure we do not hide the client
             // before event dispatch occurs
             second_client_done_fence.wait_for_signal_ready_for();
-            hide_session_by_name(test_client_2_name);
-
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1,1));
-        }
-    } server_config{fence, second_client_done_fence};
-    launch_server_process(server_config);
-    
-    struct ButtonClientOne : InputClient
-    {
-        ButtonClientOne(const mtf::CrossProcessSync& fence)
-                : InputClient(fence, test_client_name)
-        {
-        }
-        
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(2, 2))).Times(1)
+
+            server.the_shell_session_container()->for_each([&](std::shared_ptr<msh::Session> const& session) -> void
+            {
+                if (session->name() == test_client_2_name)
+                    session->hide();
+            });
+
+            server.fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(1,1));
+        }, GeometryMap(), depths);
+    launch_server_process(*server_config);
+
+    auto client_config_1 = make_event_expecting_client(test_client_name, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::MotionEventWithPosition(2, 2))).Times(1)
                 .WillOnce(mt::WakeUp(&events_received));
-        }
-    } client_1{first_client_ready_fence};
-    struct ButtonClientTwo : InputClient
-    {
-        mtf::CrossProcessSync first_client_ready;
-        mtf::CrossProcessSync done_fence;
-
-        ButtonClientTwo(mtf::CrossProcessSync const& fence, mtf::CrossProcessSync const& first_client_ready,
-                        mtf::CrossProcessSync const& done_fence) 
-            : InputClient(fence, test_client_2_name),
-              first_client_ready(first_client_ready),
-              done_fence(done_fence)
-        {
-        }
-        void exec()
-        {
-            // Ensure we stack on top of the first client
-            first_client_ready.wait_for_signal_ready_for();
-            InputClient::exec();
-        }
-
-        void expect_input(mt::WaitCondition& events_received) override
-        {
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(AnyNumber());
-            EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(1, 1))).Times(1)
-                .WillOnce(DoAll(SignalFence(&done_fence), mt::WakeUp(&events_received)));
-        }
-    } client_2{fence, first_client_ready_fence, second_client_done_fence};
-
-    // Client 2 is launched second so will be the first to receive input
-
-    launch_client_process(client_1);
-    launch_client_process(client_2);
+        });
+    auto client_config_2 = make_event_expecting_client(test_client_2_name, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+            EXPECT_CALL(handler, handle_input(mt::HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(mt::MotionEventWithPosition(1, 1))).Times(1)
+                .WillOnce(DoAll(SignalFence(&second_client_done_fence), mt::WakeUp(&events_received)));
+        });
+
+    launch_client_process(*client_config_1);
+    launch_client_process(*client_config_2);
 }
 
=== modified file 'tests/mir_test_framework/input_testing_server_options.cpp'
--- tests/mir_test_framework/input_testing_server_options.cpp	2013-09-19 18:18:35 +0000
+++ tests/mir_test_framework/input_testing_server_options.cpp	2013-11-07 17:24:53 +0000
@@ -36,8 +36,6 @@
 
 namespace mtf = mir_test_framework;
 
-namespace ms = mir::surfaces;
-namespace msh = mir::shell;
 namespace mf = mir::frontend;
 namespace mg = mir::graphics;
 namespace mi = mir::input;
@@ -45,63 +43,6 @@
 namespace geom = mir::geometry;
 namespace mtd = mir::test::doubles;
 
-namespace
-{
-class SurfaceReadinessListener
-{
-public:
-    virtual ~SurfaceReadinessListener() = default;
-    
-    virtual void channel_ready_for_input(std::string const& channel_name) = 0;
-
-protected:
-    SurfaceReadinessListener() = default;
-    SurfaceReadinessListener(SurfaceReadinessListener const&) = delete;
-    SurfaceReadinessListener& operator=(SurfaceReadinessListener const&) = delete;
-};
-
-class ProxyShell : public mf::Shell
-{
-public:
-    ProxyShell(std::shared_ptr<mf::Shell> const& underlying_shell,
-               std::shared_ptr<SurfaceReadinessListener> const listener)
-        : underlying_shell(underlying_shell),
-          listener(listener)
-    {   
-    }
-
-    ~ProxyShell() noexcept(true) = default;
-    
-    mf::SurfaceId create_surface_for(std::shared_ptr<mf::Session> const& session,
-        msh::SurfaceCreationParameters const& params)
-    {
-        return underlying_shell->create_surface_for(session, params);
-    }
-
-    std::shared_ptr<mf::Session> open_session(std::string const& name, 
-                                              std::shared_ptr<mf::EventSink> const& sink)
-    {
-        return underlying_shell->open_session(name, sink);
-    }
-
-    void close_session(std::shared_ptr<mf::Session> const& session)
-    {
-        underlying_shell->close_session(session);
-    }
-    
-    void handle_surface_created(std::shared_ptr<mf::Session> const& session)
-    {
-        underlying_shell->handle_surface_created(session);
-        listener->channel_ready_for_input(session->name());
-    }
-
-private:
-    std::shared_ptr<mf::Shell> const underlying_shell;
-    std::shared_ptr<SurfaceReadinessListener> const listener;
-};
-
-}
-
 mtf::InputTestingServerConfiguration::InputTestingServerConfiguration()
 {
 }
@@ -136,56 +77,3 @@
     
     return input_configuration;
 }
-
-std::shared_ptr<mf::Shell> mtf::InputTestingServerConfiguration::the_frontend_shell()
-{
-    struct LifecycleTracker : public SurfaceReadinessListener
-    {
-        LifecycleTracker(std::mutex& lifecycle_lock,
-                          std::condition_variable &lifecycle_condition,
-                          std::map<std::string, mtf::ClientLifecycleState> &client_lifecycles)
-            : lifecycle_lock(lifecycle_lock),
-              lifecycle_condition(lifecycle_condition),
-              client_lifecycles(client_lifecycles)
-        {
-        }
-        void channel_ready_for_input(std::string const& channel_name)
-        {
-            std::unique_lock<std::mutex> lg(lifecycle_lock);
-            client_lifecycles[channel_name] = mtf::ClientLifecycleState::appeared;
-            lifecycle_condition.notify_all();
-        }
-
-        std::mutex &lifecycle_lock;
-        std::condition_variable &lifecycle_condition;
-        std::map<std::string, mtf::ClientLifecycleState> &client_lifecycles;
-    };
-    
-    if (!frontend_shell)
-    {
-        auto readiness_listener = std::make_shared<LifecycleTracker>(lifecycle_lock,
-            lifecycle_condition,
-            client_lifecycles);
-        frontend_shell = std::make_shared<ProxyShell>(DefaultServerConfiguration::the_frontend_shell(), readiness_listener);
-    }
-
-    return frontend_shell;
-}
-
-void mtf::InputTestingServerConfiguration::wait_until_client_appears(std::string const& channel_name)
-{
-    std::unique_lock<std::mutex> lg(lifecycle_lock);
-    
-    std::chrono::minutes timeout(2);
-    auto end_time = std::chrono::system_clock::now() + timeout;
-    
-    if (client_lifecycles[channel_name] == vanished)
-    {
-        BOOST_THROW_EXCEPTION(std::runtime_error("Waiting for a client (" + channel_name + ") to appear but it has already vanished"));
-    }
-    while (client_lifecycles[channel_name] != appeared)
-    {
-        if (lifecycle_condition.wait_until(lg, end_time) == std::cv_status::timeout)
-            BOOST_THROW_EXCEPTION(std::runtime_error("Timed out waiting for client (" + channel_name + ") to appear"));
-    }
-}