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

[Robert Carr]

Simplify input acceptance tests with a better shared fixture.

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

=== modified file 'doc/component_reports.md'
--- doc/component_reports.md	2013-10-24 11:41:30 +0000
+++ doc/component_reports.md	2013-11-07 00:22:14 +0000
@@ -40,6 +40,7 @@
 Report              | Handlers
 ------------------- | --------
 rpc-report          | log,lttng
+input-receiver      | log
 
 For example, to enable the logging RPC report, one should set the
 `MIR_CLIENT_RPC_REPORT=log` environment variable.
 
=== modified file 'include/shared/mir/input/input_platform.h'
--- include/shared/mir/input/input_platform.h	2013-05-13 23:20:52 +0000
+++ include/shared/mir/input/input_platform.h	2013-11-07 00:22:14 +0000
@@ -31,6 +31,7 @@
 namespace receiver
 {
 class InputReceiverThread;
+class InputReceiverReport;
 
 // Interface for MirSurface to construct input dispatcher threads.
 class InputPlatform
@@ -39,8 +40,9 @@
     virtual ~InputPlatform() {};  
 
     virtual std::shared_ptr<InputReceiverThread> create_input_thread(int fd, std::function<void(MirEvent *)> const& callback) = 0;
-    
+
     static std::shared_ptr<InputPlatform> create();
+    static std::shared_ptr<InputPlatform> create(std::shared_ptr<InputReceiverReport> const& report);
 
 protected:
     InputPlatform() = default;
 
=== added file 'include/shared/mir/input/input_receiver_report.h'
--- include/shared/mir/input/input_receiver_report.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/input/input_receiver_report.h	2013-11-07 00:22:14 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_INPUT_RECEIVER_REPORT_H_
+#define MIR_CLIENT_INPUT_RECEIVER_REPORT_H_
+
+#include <mir_toolkit/event.h>
+
+namespace mir
+{
+namespace input
+{
+namespace receiver
+{
+
+class InputReceiverReport
+{
+public:
+    virtual ~InputReceiverReport() = default;
+
+    virtual void received_event(MirEvent const& event) = 0;
+
+protected:
+    InputReceiverReport() = default;
+    InputReceiverReport(InputReceiverReport const&) = delete;
+    InputReceiverReport& operator=(InputReceiverReport const&) = delete;
+};
+
+}
+}
+}
+
+#endif /* MIR_CLIENT_INPUT_RECEIVER_REPORT_H_ */
 
=== added file 'include/shared/mir/input/null_input_receiver_report.h'
--- include/shared/mir/input/null_input_receiver_report.h	1970-01-01 00:00:00 +0000
+++ include/shared/mir/input/null_input_receiver_report.h	2013-11-07 00:22:14 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_NULL_INPUT_RECEIVER_REPORT_H_
+#define MIR_CLIENT_NULL_INPUT_RECEIVER_REPORT_H_
+
+#include "mir/input/input_receiver_report.h"
+
+#include <mir_toolkit/event.h>
+
+namespace mir
+{
+namespace input
+{
+namespace receiver
+{
+
+class NullInputReceiverReport : public InputReceiverReport
+{
+public:
+    NullInputReceiverReport() = default;
+    virtual ~NullInputReceiverReport() = default;
+
+    void received_event(MirEvent const& /* event */) {}
+};
+
+}
+}
+}
+
+#endif /* MIR_CLIENT_NULL_INPUT_RECEIVER_REPORT_H_ */
 
=== 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 00:22:14 +0000
@@ -65,9 +65,10 @@
     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);
 
 
=== modified file 'src/client/CMakeLists.txt'
--- src/client/CMakeLists.txt	2013-10-21 16:02:28 +0000
+++ src/client/CMakeLists.txt	2013-11-07 00:22:14 +0000
@@ -29,6 +29,7 @@
   mir_wait_handle.cpp
   mir_surface.cpp
   logging/rpc_report.cpp
+  logging/input_receiver_report.cpp
   default_connection_configuration.cpp
   surface_map.cpp
   lifecycle_control.cpp
 
=== modified file 'src/client/default_connection_configuration.cpp'
--- src/client/default_connection_configuration.cpp	2013-08-28 03:41:48 +0000
+++ src/client/default_connection_configuration.cpp	2013-11-07 00:22:14 +0000
@@ -24,7 +24,9 @@
 #include "mir/logging/dumb_console_logger.h"
 #include "native_client_platform_factory.h"
 #include "mir/input/input_platform.h"
+#include "mir/input/null_input_receiver_report.h"
 #include "logging/rpc_report.h"
+#include "logging/input_receiver_report.h"
 #include "lttng/rpc_report.h"
 #include "connection_surface_map.h"
 #include "lifecycle_control.h"
@@ -88,9 +90,9 @@
 mcl::DefaultConnectionConfiguration::the_input_platform()
 {
     return input_platform(
-        []
+        [this]
         {
-            return mir::input::receiver::InputPlatform::create();
+            return mir::input::receiver::InputPlatform::create(the_input_receiver_report());
         });
 }
 
@@ -118,6 +120,22 @@
         });
 }
 
+std::shared_ptr<mir::input::receiver::InputReceiverReport>
+mcl::DefaultConnectionConfiguration::the_input_receiver_report()
+{
+    return input_receiver_report(
+        [this] () -> std::shared_ptr<mir::input::receiver::InputReceiverReport>
+        {
+            auto val_raw = getenv("MIR_CLIENT_INPUT_RECEIVER_REPORT");
+            std::string const val{val_raw ? val_raw : off_opt_val};
+            
+            if (val == log_opt_val)
+                return std::make_shared<mcl::logging::InputReceiverReport>(the_logger());
+            else
+                return std::make_shared<mir::input::receiver::NullInputReceiverReport>();
+        });
+}
+
 std::shared_ptr<mcl::DisplayConfiguration> mcl::DefaultConnectionConfiguration::the_display_configuration()
 {
     return display_configuration(
 
=== modified file 'src/client/default_connection_configuration.h'
--- src/client/default_connection_configuration.h	2013-08-28 03:41:48 +0000
+++ src/client/default_connection_configuration.h	2013-11-07 00:22:14 +0000
@@ -27,6 +27,13 @@
 
 namespace mir
 {
+namespace input
+{
+namespace receiver
+{
+class InputReceiverReport;
+}
+}
 namespace client
 {
 
@@ -50,6 +57,7 @@
 
     virtual std::string the_socket_file();
     virtual std::shared_ptr<rpc::RpcReport> the_rpc_report();
+    virtual std::shared_ptr<input::receiver::InputReceiverReport> the_input_receiver_report();
 
 protected:
     CachedPtr<rpc::MirBasicRpcChannel> rpc_channel;
@@ -61,6 +69,7 @@
     CachedPtr<LifecycleControl> lifecycle_control;
 
     CachedPtr<rpc::RpcReport> rpc_report;
+    CachedPtr<input::receiver::InputReceiverReport> input_receiver_report;
 
 private:
     std::string const socket_file;
 
=== added file 'src/client/logging/input_receiver_report.cpp'
--- src/client/logging/input_receiver_report.cpp	1970-01-01 00:00:00 +0000
+++ src/client/logging/input_receiver_report.cpp	2013-11-07 00:22:14 +0000
@@ -0,0 +1,125 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "input_receiver_report.h"
+
+#include "mir/logging/logger.h"
+
+#include <boost/throw_exception.hpp>
+
+#include <sstream>
+#include <stdexcept>
+
+namespace ml = mir::logging;
+namespace mcll = mir::client::logging;
+
+namespace
+{
+std::string const component{"input-receiver"};
+}
+
+mcll::InputReceiverReport::InputReceiverReport(std::shared_ptr<ml::Logger> const& logger)
+    : logger{logger}
+{
+}
+
+namespace
+{
+
+static void format_key_event(std::stringstream &ss, MirKeyEvent const& ev)
+{
+    ss << "MirKeyEvent {" << std::endl;
+    ss << "  device_id: " << ev.device_id << std::endl;
+    ss << "  source_id: " << ev.source_id << std::endl;
+    ss << "  action: " << ev.action << std::endl;
+    ss << "  flags: " << ev.flags << std::endl;
+    ss << "  modifiers: " << ev.modifiers << std::endl;
+    ss << "  key_code: " << ev.key_code << std::endl;
+    ss << "  scan_code: " << ev.scan_code << std::endl;
+    ss << "  repeat_count: " << ev.repeat_count << std::endl;
+    ss << "  down_time: " << ev.down_time << std::endl;
+    ss << "  event_time: " << ev.event_time << std::endl;
+    ss << "  is_system_key: " << ev.is_system_key << std::endl;
+    ss << "}";
+}
+static void format_motion_event(std::stringstream &ss, MirMotionEvent const& ev)
+{
+    ss << "MirMotionEvent{" << std::endl;
+    ss << "  type: motion" << std::endl;
+    ss << "  device_id: " << ev.device_id << std::endl;
+    ss << "  source_id: " << ev.source_id << std::endl;
+    ss << "  action: " << ev.action << std::endl;
+    ss << "  flags: " << ev.flags << std::endl;
+    ss << "  modifiers: " << ev.modifiers << std::endl;
+    ss << "  edge_flags: " << ev.edge_flags << std::endl;
+    ss << "  button_state: " << ev.button_state << std::endl;
+    ss << "  x_offset: " << ev.x_offset << std::endl;
+    ss << "  y_offset: " << ev.y_offset << std::endl;
+    ss << "  x_precision: " << ev.x_precision << std::endl;
+    ss << "  y_precision: " << ev.y_precision << std::endl;
+    ss << "  down_time: " << ev.down_time << std::endl;
+    ss << "  event_time: " << ev.event_time << std::endl;
+    ss << "  pointer_count: " << ev.pointer_count << std::endl;
+    for (unsigned int i = 0; i < ev.pointer_count; i++)
+    {
+        ss << "  pointer[" << i << "]{" << std::endl;
+        ss << "    id: " << ev.pointer_coordinates[i].id << std::endl;
+        ss << "    x: " << ev.pointer_coordinates[i].x << std::endl;
+        ss << "    raw_x: " << ev.pointer_coordinates[i].raw_x << std::endl;
+        ss << "    y: " << ev.pointer_coordinates[i].y << std::endl;
+        ss << "    raw_y: " << ev.pointer_coordinates[i].raw_y << std::endl;
+        ss << "    touch_major: " << ev.pointer_coordinates[i].touch_major << std::endl;
+        ss << "    touch_minor: " << ev.pointer_coordinates[i].touch_minor << std::endl;
+        ss << "    size: " << ev.pointer_coordinates[i].size << std::endl;
+        ss << "    pressure: " << ev.pointer_coordinates[i].pressure << std::endl;
+        ss << "    orientation: " << ev.pointer_coordinates[i].orientation << std::endl;
+        ss << "    vscroll: " << ev.pointer_coordinates[i].vscroll << std::endl;
+        ss << "    hscroll: " << ev.pointer_coordinates[i].hscroll << std::endl;
+        ss << "  }" << std::endl;
+    }
+    ss << "}";
+}
+
+static void format_event(std::stringstream &ss, MirEvent const& ev)
+{
+    switch (ev.type)
+    {
+    case mir_event_type_key:
+        format_key_event(ss, ev.key);
+        break;
+    case mir_event_type_motion:
+        format_motion_event(ss, ev.motion);
+        break;
+    default:
+        BOOST_THROW_EXCEPTION(std::runtime_error("Unexpected event type"));
+    }
+}
+
+}
+
+void mcll::InputReceiverReport::received_event(
+    MirEvent const& event)
+{
+    std::stringstream ss;
+
+    ss << "Received event:" << std::endl;
+    
+    format_event(ss, event);
+
+    logger->log<ml::Logger::debug>(ss.str(), component);
+}
 
=== added file 'src/client/logging/input_receiver_report.h'
--- src/client/logging/input_receiver_report.h	1970-01-01 00:00:00 +0000
+++ src/client/logging/input_receiver_report.h	2013-11-07 00:22:14 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Alexandros Frantzis <[e-mail]>
+ */
+
+#ifndef MIR_CLIENT_LOGGING_INPUT_RECEIVER_REPORT_H_
+#define MIR_CLIENT_LOGGING_INPUT_RECEIVER_REPORT_H_
+
+#include "mir/input/input_receiver_report.h"
+
+#include <memory>
+
+namespace mir
+{
+
+namespace logging
+{
+class Logger;
+}
+
+namespace client
+{
+namespace logging
+{
+
+class InputReceiverReport : public input::receiver::InputReceiverReport
+{
+public:
+    InputReceiverReport(std::shared_ptr<mir::logging::Logger> const& logger);
+
+    void received_event(MirEvent const& event) override;
+
+private:
+    std::shared_ptr<mir::logging::Logger> const logger;
+};
+
+}
+}
+}
+
+#endif /* MIR_CLIENT_LOGGING_INPUT_RECEIVER_REPORT_H_ */
 
=== modified file 'src/shared/input/android/android_input_platform.cpp'
--- src/shared/input/android/android_input_platform.cpp	2013-05-13 23:20:52 +0000
+++ src/shared/input/android/android_input_platform.cpp	2013-11-07 00:22:14 +0000
@@ -20,10 +20,13 @@
 #include "android_input_receiver.h"
 #include "android_input_receiver_thread.h"
 
+#include "mir/input/null_input_receiver_report.h"
+
 namespace mircv = mir::input::receiver;
 namespace mircva = mircv::android;
 
-mircva::AndroidInputPlatform::AndroidInputPlatform()
+mircva::AndroidInputPlatform::AndroidInputPlatform(std::shared_ptr<mircv::InputReceiverReport> const& report)
+    : report(report)
 {
 }
 
@@ -34,11 +37,16 @@
 std::shared_ptr<mircv::InputReceiverThread> mircva::AndroidInputPlatform::create_input_thread(
     int fd, std::function<void(MirEvent*)> const& callback)
 {
-    auto receiver = std::make_shared<mircva::InputReceiver>(fd);
+    auto receiver = std::make_shared<mircva::InputReceiver>(fd, report);
     return std::make_shared<mircva::InputReceiverThread>(receiver, callback);
 }
 
 std::shared_ptr<mircv::InputPlatform> mircv::InputPlatform::create()
 {
-    return std::make_shared<mircva::AndroidInputPlatform>();
+    return create(std::make_shared<mircv::NullInputReceiverReport>());
+}
+
+std::shared_ptr<mircv::InputPlatform> mircv::InputPlatform::create(std::shared_ptr<mircv::InputReceiverReport> const& report)
+{
+    return std::make_shared<mircva::AndroidInputPlatform>(report);
 }
 
=== modified file 'src/shared/input/android/android_input_platform.h'
--- src/shared/input/android/android_input_platform.h	2013-05-13 23:20:52 +0000
+++ src/shared/input/android/android_input_platform.h	2013-11-07 00:22:14 +0000
@@ -34,7 +34,7 @@
 class AndroidInputPlatform : public InputPlatform
 {
 public:
-    AndroidInputPlatform();
+    AndroidInputPlatform(std::shared_ptr<InputReceiverReport> const& report);
     virtual ~AndroidInputPlatform();  
 
     std::shared_ptr<InputReceiverThread> create_input_thread(int fd, std::function<void(MirEvent *)> const& callback);
@@ -42,6 +42,9 @@
 protected:
     AndroidInputPlatform(const AndroidInputPlatform&) = delete;
     AndroidInputPlatform& operator=(const AndroidInputPlatform&) = delete;
+
+private:
+    std::shared_ptr<InputReceiverReport> const report;
 };
 
 }
 
=== modified file 'src/shared/input/android/android_input_receiver.cpp'
--- src/shared/input/android/android_input_receiver.cpp	2013-05-24 18:20:37 +0000
+++ src/shared/input/android/android_input_receiver.cpp	2013-11-07 00:22:14 +0000
@@ -19,6 +19,7 @@
 #include "android_input_receiver.h"
 
 #include "mir/input/xkb_mapper.h"
+#include "mir/input/input_receiver_report.h"
 #include "mir/input/android/android_input_lexicon.h"
 
 #include <androidfw/InputTransport.h>
@@ -29,8 +30,10 @@
 
 namespace mia = mir::input::android;
 
-mircva::InputReceiver::InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel)
+mircva::InputReceiver::InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel,
+                                     std::shared_ptr<mircv::InputReceiverReport> const& report)
   : input_channel(input_channel),
+    report(report),
     input_consumer(std::make_shared<droidinput::InputConsumer>(input_channel)),
     looper(new droidinput::Looper(true)),
     fd_added(false),
@@ -38,8 +41,10 @@
 {
 }
 
-mircva::InputReceiver::InputReceiver(int fd)
+mircva::InputReceiver::InputReceiver(int fd,
+                                     std::shared_ptr<mircv::InputReceiverReport> const& report)
   : input_channel(new droidinput::InputChannel(droidinput::String8(""), fd)), 
+    report(report),
     input_consumer(std::make_shared<droidinput::InputConsumer>(input_channel)),
     looper(new droidinput::Looper(true)),
     fd_added(false),
@@ -84,6 +89,8 @@
         map_key_event(xkb_mapper, ev);
 
         input_consumer->sendFinishedSignal(event_sequence_id, true);
+        
+        report->received_event(ev);
 
         return true;
     }
 
=== modified file 'src/shared/input/android/android_input_receiver.h'
--- src/shared/input/android/android_input_receiver.h	2013-05-24 18:20:37 +0000
+++ src/shared/input/android/android_input_receiver.h	2013-11-07 00:22:14 +0000
@@ -43,6 +43,7 @@
 namespace receiver
 {
 class XKBMapper;
+class InputReceiverReport;
 
 namespace android
 {
@@ -51,8 +52,10 @@
 class InputReceiver
 {
 public:
-    InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel);
-    InputReceiver(int fd);
+    InputReceiver(droidinput::sp<droidinput::InputChannel> const& input_channel,
+                  std::shared_ptr<InputReceiverReport> const& report);
+    InputReceiver(int fd,
+                  std::shared_ptr<InputReceiverReport> const& report);
 
     virtual ~InputReceiver();
     int fd() const;
@@ -71,6 +74,8 @@
 
 private:
     droidinput::sp<droidinput::InputChannel> input_channel;
+    std::shared_ptr<InputReceiverReport> const report;
+
     std::shared_ptr<droidinput::InputConsumer> input_consumer;
     droidinput::PreallocatedInputEventFactory event_factory;
     droidinput::sp<droidinput::Looper> looper;
 
=== 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 00:22:14 +0000
@@ -248,6 +248,16 @@
     return true;
 }
 
+MATCHER(HoverMoveEvent, "")
+{
+    if (arg->type != mir_event_type_motion)
+        return false;
+    if (arg->motion.action != mir_motion_action_hover_move)
+        return false;
+
+    return true;
+}
+
 MATCHER_P2(ButtonDownEvent, x, y, "")
 {
     if (arg->type != mir_event_type_motion)
@@ -302,194 +312,6 @@
 
 }
 
-
-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
 {
 typedef std::map<std::string, geom::Rectangle> GeometryMap;
@@ -497,34 +319,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(KeyDownEvent())).Times(2);
+            EXPECT_CALL(handler, handle_input(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(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));
+        });
+    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(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!
+         });
+    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(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 +578,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(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));
+        });
+    auto client_2 = make_event_expecting_client(test_client_2, fence,
+         [&](MockInputHandler& handler, mt::WaitCondition& events_received)
+         {
+             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));
+        });
+
+    launch_client_process(*client_1);
+    launch_client_process(*client_2);
 }
 
 namespace
@@ -639,6 +643,7 @@
     std::vector<geom::Rectangle> const input_rectangles;
 };
 }
+
 TEST_F(TestClientInput, clients_do_not_receive_motion_outside_input_region)
 {
     using namespace ::testing;
@@ -670,7 +675,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
         {
@@ -697,35 +702,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(HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(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(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)
                     .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 +738,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(HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(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(ButtonDownEvent(51, 1))).Times(1);
+                EXPECT_CALL(handler, handle_input(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(HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(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(ButtonDownEvent(1, 1))).Times(1);
+              EXPECT_CALL(handler, handle_input(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 +813,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(HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(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(HoverEnterEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(HoverExitEvent())).Times(AnyNumber());
+            EXPECT_CALL(handler, handle_input(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/unit-tests/client/input/test_android_input_receiver.cpp'
--- tests/unit-tests/client/input/test_android_input_receiver.cpp	2013-05-31 16:06:07 +0000
+++ tests/unit-tests/client/input/test_android_input_receiver.cpp	2013-11-07 00:22:14 +0000
@@ -17,8 +17,10 @@
  */
 
 #include "src/shared/input/android/android_input_receiver.h"
+#include "mir/input/null_input_receiver_report.h"
 #include "mir_toolkit/event.h"
 
+
 #include <androidfw/InputTransport.h>
 
 #include <gmock/gmock.h>
@@ -27,7 +29,8 @@
 #include <unistd.h>
 #include <memory>
 
-namespace mircva = mir::input::receiver::android;
+namespace mircv = mir::input::receiver;
+namespace mircva = mircv::android;
 
 namespace droidinput = android;
 
@@ -142,14 +145,14 @@
 
 TEST_F(AndroidInputReceiverSetup, receiever_takes_channel_fd)
 {
-    mircva::InputReceiver receiver(client_fd);
+    mircva::InputReceiver receiver(client_fd, std::make_shared<mircv::NullInputReceiverReport>());
     
     EXPECT_EQ(client_fd, receiver.fd());
 }
 
 TEST_F(AndroidInputReceiverSetup, receiver_receives_key_events)
 {
-    mircva::InputReceiver receiver(client_fd);
+    mircva::InputReceiver receiver(client_fd, std::make_shared<mircv::NullInputReceiverReport>());
     TestingInputProducer producer(server_fd);
     
     producer.produce_a_key_event();
@@ -165,7 +168,7 @@
 
 TEST_F(AndroidInputReceiverSetup, receiver_handles_events)
 {
-    mircva::InputReceiver receiver(client_fd);
+    mircva::InputReceiver receiver(client_fd, std::make_shared<mircv::NullInputReceiverReport>());
     TestingInputProducer producer(server_fd);
     
     producer.produce_a_key_event();
@@ -181,7 +184,7 @@
 
 TEST_F(AndroidInputReceiverSetup, receiver_consumes_batched_motion_events)
 {
-    mircva::InputReceiver receiver(client_fd);
+    mircva::InputReceiver receiver(client_fd, std::make_shared<mircv::NullInputReceiverReport>());
     TestingInputProducer producer(server_fd);
     
     // Produce 3 motion events before client handles any.
 
=== modified file 'tests/unit-tests/client/input/test_android_input_receiver_thread.cpp'
--- tests/unit-tests/client/input/test_android_input_receiver_thread.cpp	2013-05-13 23:20:52 +0000
+++ tests/unit-tests/client/input/test_android_input_receiver_thread.cpp	2013-11-07 00:22:14 +0000
@@ -19,6 +19,8 @@
 #include "src/shared/input/android/android_input_receiver_thread.h"
 #include "src/shared/input/android/android_input_receiver.h"
 
+#include "mir/input/null_input_receiver_report.h"
+
 #include "mir_toolkit/mir_client_library.h"
 
 #include <gtest/gtest.h>
@@ -30,7 +32,8 @@
 
 #include <fcntl.h>
 
-namespace mircva = mir::input::receiver::android;
+namespace mircv = mir::input::receiver;
+namespace mircva = mircv::android;
 
 namespace
 {
@@ -43,7 +46,7 @@
 struct MockInputReceiver : public mircva::InputReceiver
 {
     MockInputReceiver(int fd)
-      : InputReceiver(fd)
+      : InputReceiver(fd, std::make_shared<mircv::NullInputReceiverReport>())
     {
     }
     MOCK_METHOD1(next_event, bool(MirEvent &));