Merge lp:~robertcarr/mir/improve-input-acceptance into lp:~mir-team/mir/trunk

[Robert Carr]

Refactor input acceptance test fixtures.

Work on making it easier to define a variety of input acceptance tests by pulling out and refactoring the input test fixture from test_client_input.cpp, there is also some cleanup on the client side. Hope to find time to continue this soon and add client placement support used in "multiple_clients_receive_motion_in_windows" to the fixture. From here it should be easy to write a lot of input acceptance tests for various scenarios!

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:745
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/improve-input-acceptance/+merge/169311/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/mir-ci/728/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/905
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/787
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/213/console

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/728/rebuild

review: Needs Fixing (continuous-integration)

[Daniel van Vugt (vanvugt)]

I feel overwhelmed by class names that make no sense to me (e.g. InputRegistrarListener). But that's not really anything new from this proposal.

In other cases, the names are unnecessarily verbose. For example "InputReceivingClient" could be "InputClient". Repeated in multiple locations, it makes the code easier to read if it's shorter.

But some more concrete issues:

1. Lines 38-58: Might be about time to indent the namespace declarations so they're readable.

2. This test hangs(!):
        Start 5: acceptance-tests.TestClientInput.*
and specifically hangs at:

[----------] 5 tests from TestClientInput
[ RUN ] TestClientInput.clients_receive_key_input
[ OK ] TestClientInput.clients_receive_key_input (15 ms)
[ RUN ] TestClientInput.clients_receive_us_english_mapped_keys
[ OK ] TestClientInput.clients_receive_us_english_mapped_keys (14 ms)
[ RUN ] TestClientInput.clients_receive_motion_inside_window
[ OK ] TestClientInput.clients_receive_motion_inside_window (12 ms)
[ RUN ] TestClientInput.clients_receive_button_events_inside_window
[ OK ] TestClientInput.clients_receive_button_events_inside_window (16 ms)
[ RUN ] TestClientInput.multiple_clients_receive_motion_inside_windows

review: Needs Fixing

[Robert Carr (robertcarr)]

Whoops at the hang! r745 was supposed to be a harmless cleanup which of course broke everything.Fixed

I made some renames, InputRegistrarListener->SurfaceReadinessListener.

>> Lines 38-58: Might be about time to indent the namespace declarations so they're readable.

I don't want to have a different style only in this file. Perhaps it is indicative that mir_test_framework should be mir::test::framework though.

[Robert Carr (robertcarr)]

InputReceivingClient->InputClient

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:747
http://jenkins.qa.ubuntu.com/job/mir-ci/735/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/914
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/796
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/220
        deb: http://jenkins.qa.ubuntu.com/job/mir-raring-amd64-ci/220/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=quantal,flavor=amd64/422

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/735/rebuild

review: Approve (continuous-integration)

=== added file 'include/test/mir_test_framework/input_testing_server_configuration.h'
--- include/test/mir_test_framework/input_testing_server_configuration.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_framework/input_testing_server_configuration.h	2013-06-14 16:12:27 +0000
@@ -0,0 +1,97 @@
+/*
+ * 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]>
+ */
+
+
+#ifndef MIR_TEST_INPUT_TESTING_SERVER_CONFIGURATION_H_
+#define MIR_TEST_INPUT_TESTING_SERVER_CONFIGURATION_H_
+
+#include "mir_test_framework/testing_server_configuration.h"
+
+#include "mir/geometry/rectangle.h"
+
+#include <map>
+#include <string>
+#include <mutex>
+#include <condition_variable>
+#include <atomic>
+#include <thread>
+
+namespace mir
+{
+namespace input
+{
+namespace android
+{
+class FakeEventHub;
+}
+}
+namespace graphics
+{
+class ViewableArea;
+}
+namespace test
+{
+namespace doubles
+{
+class FakeEventHubInputConfiguration;
+}
+}
+}
+
+namespace mir_test_framework
+{
+
+enum ClientLifecycleState { starting, appeared, vanished };
+
+class InputTestingServerConfiguration : public TestingServerConfiguration
+{
+public:
+    InputTestingServerConfiguration();
+
+    void exec();
+    void on_exit();
+    
+    std::shared_ptr<mir::input::InputConfiguration> the_input_configuration() override;
+    std::shared_ptr<mir::surfaces::InputRegistrar> the_input_registrar() override;
+    std::shared_ptr<mir::graphics::ViewableArea> the_viewable_area() override;
+
+protected:
+    virtual mir::geometry::Rectangle the_screen_geometry();
+
+    virtual void inject_input() = 0;
+    mir::input::android::FakeEventHub* fake_event_hub;
+
+    void wait_until_client_appears(std::string const& surface_name);
+    void wait_until_client_vanishes(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::surfaces::InputRegistrar> input_registrar;
+    std::shared_ptr<mir::graphics::ViewableArea> view_area;
+};
+
+}
+
+#endif /* MIR_TEST_INPUT_TESTING_SERVER_CONFIGURATION_H_ */

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-05-30 19:24:29 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-06-14 16:12:27 +0000
@@ -27,11 +27,11 @@
 #include "mir_toolkit/mir_client_library.h"
 
 #include "mir_test/fake_shared.h"
-#include "mir_test/fake_event_hub_input_configuration.h"
 #include "mir_test/fake_event_hub.h"
 #include "mir_test/event_factory.h"
 #include "mir_test/wait_condition.h"
 #include "mir_test_framework/display_server_test_fixture.h"
+#include "mir_test_framework/input_testing_server_configuration.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -60,86 +60,12 @@
     char const* const mir_test_socket = mtf::test_socket_file().c_str();
 }
 
-#include "mir/input/surface_target.h"
-
 namespace
 {
-struct FocusNotifyingInputTargeter : public msh::InputTargeter
-{
-    FocusNotifyingInputTargeter(std::shared_ptr<msh::InputTargeter> const& real_targeter,
-                                std::function<void(void)> const& focus_set)
-      : real_targeter(real_targeter),
-        focus_set(focus_set)
-    {
-
-    }
-    virtual ~FocusNotifyingInputTargeter() noexcept(true) {}
-    
-    void focus_changed(std::shared_ptr<mi::SurfaceTarget const> const& surface) override
-    {
-        real_targeter->focus_changed(surface);
-
-        // We need a synchronization primitive inorder to halt test event injection
-        // until after a surface has taken focus (lest the events be discarded).
-        focus_set();
-    }
-    void focus_cleared()
-    {
-        real_targeter->focus_cleared();
-    }
-
-    std::shared_ptr<msh::InputTargeter> const real_targeter;
-    std::function<void(void)> focus_set;
-};
-
-struct FakeInputServerConfiguration : public mir_test_framework::TestingServerConfiguration
-{
-    FakeInputServerConfiguration()
-      : input_config(the_event_filters(), the_display(), std::shared_ptr<mi::CursorListener>(), the_input_report())
-    {
-    }
-
-    virtual void inject_input_after_focus()
-    {
-    }
-    
-    std::shared_ptr<mi::InputConfiguration> the_input_configuration() override
-    {
-        fake_event_hub = input_config.the_fake_event_hub();
-        fake_event_hub->synthesize_builtin_keyboard_added();
-        fake_event_hub->synthesize_builtin_cursor_added();
-        fake_event_hub->synthesize_device_scan_complete();
-
-        return mt::fake_shared(input_config);
-    }
-    
-    std::shared_ptr<mi::InputManager> the_input_manager() override
-    {
-        return DefaultServerConfiguration::the_input_manager();
-    }
-    std::shared_ptr<ms::InputRegistrar> the_input_registrar() override
-    {        
-        return DefaultServerConfiguration::the_input_registrar();
-    }
-
-    std::shared_ptr<msh::InputTargeter>
-    the_input_targeter() override
-    {
-        return input_targeter(
-            [this]()
-            {
-                return std::make_shared<FocusNotifyingInputTargeter>(DefaultServerConfiguration::the_input_targeter(), std::bind(std::mem_fn(&FakeInputServerConfiguration::inject_input_after_focus), this));
-            });
-    }
-
-    mtd::FakeEventHubInputConfiguration input_config;
-    mia::FakeEventHub* fake_event_hub;
-};
-
-
-struct ClientConfigCommon : TestingClientConfiguration
-{
-    ClientConfigCommon() :
+
+struct ClientConfig : mtf::TestingClientConfiguration
+{
+    ClientConfig() :
         connection(0),
         surface(0)
     {
@@ -147,19 +73,19 @@
 
     static void connection_callback(MirConnection* connection, void* context)
     {
-        ClientConfigCommon* config = reinterpret_cast<ClientConfigCommon *>(context);
+        ClientConfig* config = reinterpret_cast<ClientConfig *>(context);
         config->connection = connection;
     }
 
     static void create_surface_callback(MirSurface* surface, void* context)
     {
-        ClientConfigCommon* config = reinterpret_cast<ClientConfigCommon *>(context);
+        ClientConfig* config = reinterpret_cast<ClientConfig *>(context);
         config->surface_created(surface);
     }
 
     static void release_surface_callback(MirSurface* surface, void* context)
     {
-        ClientConfigCommon* config = reinterpret_cast<ClientConfigCommon *>(context);
+        ClientConfig* config = reinterpret_cast<ClientConfig *>(context);
         config->surface_released(surface);
     }
 
@@ -184,29 +110,24 @@
 
 struct MockInputHandler
 {
-    MOCK_METHOD1(handle_input, bool(MirEvent const*));
+    MOCK_METHOD1(handle_input, void(MirEvent const*));
 };
 
-struct InputReceivingClient : ClientConfigCommon
+struct InputClient : ClientConfig
 {
-    InputReceivingClient(int events_to_receive)
-      : events_to_receive(events_to_receive),
-        events_received(0)
+    InputClient(std::string const& surface_name)
+      : surface_name(surface_name)
     {
-        assert(events_to_receive <= max_events_to_receive);
     }
 
     static void handle_input(MirSurface* /* surface */, MirEvent const* ev, void* context)
     {
-        auto client = static_cast<InputReceivingClient *>(context);
+        auto client = static_cast<InputClient *>(context);
 
-        if (client->handler->handle_input(ev))
-        {
-            client->event_received[client->events_received].wake_up_everyone();
-            client->events_received++;
-        }
+        client->handler->handle_input(ev);
     }
-    virtual void expect_input()
+
+    virtual void expect_input(mt::WaitCondition&)
     {
     }
     
@@ -214,7 +135,7 @@
     {
         MirSurfaceParameters const request_params =
          {
-             __PRETTY_FUNCTION__,
+             surface_name.c_str(),
              surface_width, surface_height,
              mir_pixel_format_abgr_8888,
              mir_buffer_usage_hardware
@@ -226,7 +147,7 @@
     {
         handler = std::make_shared<MockInputHandler>();
 
-        expect_input();
+        expect_input(events_received);
 
         mir_wait_for(mir_connect(
             mir_test_socket,
@@ -245,9 +166,7 @@
 
          mir_surface_set_event_handler(surface, &event_delegate);
 
-
-         for (int i = 0; i < events_to_receive; i++)
-             event_received[i].wait_for_at_most_seconds(5);
+         events_received.wait_for_at_most_seconds(60);
 
          mir_surface_release_sync(surface);
          
@@ -259,12 +178,10 @@
     }
     
     std::shared_ptr<MockInputHandler> handler;
-    static int const max_events_to_receive = 4;
-    mt::WaitCondition event_received[max_events_to_receive];
-    
-    int events_to_receive;
-    int events_received;
-
+    mt::WaitCondition events_received;
+    
+    std::string const surface_name;
+    
     static int const surface_width = 100;
     static int const surface_height = 100;
 };
@@ -343,13 +260,13 @@
     using namespace ::testing;
     
     int const num_events_produced = 3;
+    static std::string const test_client_name = "1";
 
-    struct InputProducingServerConfiguration : FakeInputServerConfiguration
+    struct ServerConfiguration : mtf::InputTestingServerConfiguration
     {
-        void inject_input_after_focus()
+        void inject_input()
         {
-            // We send multiple events in order to verify the client is handling them
-            // and server dispatch does not become backed up.
+            wait_until_client_appears(test_client_name);
             for (int i = 0; i < num_events_produced; i++)
                 fake_event_hub->synthesize_event(mis::a_key_down_event()
                                                  .of_scancode(KEY_ENTER));
@@ -357,14 +274,17 @@
     } server_config;
     launch_server_process(server_config);
     
-    struct KeyReceivingClient : InputReceivingClient
+    struct KeyReceivingClient : InputClient
     {
-        KeyReceivingClient() : InputReceivingClient(num_events_produced) {}
-        void expect_input()
+        KeyReceivingClient() : InputClient(test_client_name) {}
+        void expect_input(mt::WaitCondition& events_received) override
         {
             using namespace ::testing;
-            EXPECT_CALL(*handler, handle_input(KeyDownEvent())).Times(num_events_produced)
-                .WillRepeatedly(Return(true));
+            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;
     launch_client_process(client_config);
@@ -373,11 +293,14 @@
 TEST_F(TestClientInput, clients_receive_us_english_mapped_keys)
 {
     using namespace ::testing;
+    static std::string const test_client_name = "1";
     
-    struct InputProducingServerConfiguration : FakeInputServerConfiguration
+    struct ServerConfiguration : mtf::InputTestingServerConfiguration
     {
-        void inject_input_after_focus()
+        void inject_input()
         {
+            wait_until_client_appears(test_client_name);
+
             fake_event_hub->synthesize_event(mis::a_key_down_event()
                                              .of_scancode(KEY_LEFTSHIFT));
             fake_event_hub->synthesize_event(mis::a_key_down_event()
@@ -387,55 +310,57 @@
     } server_config;
     launch_server_process(server_config);
     
-    struct KeyReceivingClient : InputReceivingClient
+    struct KeyReceivingClient : InputClient
     {
-        KeyReceivingClient() : InputReceivingClient(2) {}
+        KeyReceivingClient() : InputClient(test_client_name) {}
 
-        void expect_input()
+        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)
-                .WillOnce(Return(true));
+            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(Return(true));
+                .WillOnce(mt::WakeUp(&events_received));
         }
     } client_config;
     launch_client_process(client_config);
 }
 
-// TODO: This assumes that clients are placed by shell at 0,0. Which probably isn't quite safe!
 TEST_F(TestClientInput, clients_receive_motion_inside_window)
 {
     using namespace ::testing;
+    static std::string const test_client_name = "1";
     
-    struct InputProducingServerConfiguration : FakeInputServerConfiguration
+    struct ServerConfiguration : public mtf::InputTestingServerConfiguration
     {
-        void inject_input_after_focus()
+        void inject_input()
         {
-            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(InputReceivingClient::surface_width,
-                                                                                 InputReceivingClient::surface_height));
+            wait_until_client_appears(test_client_name);
+            
+            fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(InputClient::surface_width,
+                                                                                 InputClient::surface_height));
             fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(2,2));
         }
     } server_config;
     launch_server_process(server_config);
     
-    struct MotionReceivingClient : InputReceivingClient
+    struct MotionReceivingClient : InputClient
     {
-        MotionReceivingClient() : InputReceivingClient(2) {}
+        MotionReceivingClient() : InputClient(test_client_name) {}
 
-        void expect_input()
+        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).WillOnce(Return(true));
+            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1);
             EXPECT_CALL(*handler, handle_input(
-                MotionEventWithPosition(InputReceivingClient::surface_width, 
-                                        InputReceivingClient::surface_height))).Times(1).WillOnce(Return(true));
+                MotionEventWithPosition(InputClient::surface_width, 
+                                        InputClient::surface_height))).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
             // But we should not receive an event for the second movement outside of our surface!
         }
     } client_config;
@@ -446,27 +371,31 @@
 {
     using namespace ::testing;
     
-    struct InputProducingServerConfiguration : FakeInputServerConfiguration
+    static std::string const test_client_name = "1";
+    
+    struct ServerConfiguration : public mtf::InputTestingServerConfiguration
     {
-        void inject_input_after_focus()
+        void inject_input()
         {
+            wait_until_client_appears(test_client_name);
             fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
         }
     } server_config;
     launch_server_process(server_config);
     
-    struct ButtonReceivingClient : InputReceivingClient
+    struct ButtonReceivingClient : InputClient
     {
-        ButtonReceivingClient() : InputReceivingClient(1) {}
+        ButtonReceivingClient() : InputClient(test_client_name) {}
 
-        void expect_input()
+        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(Return(true));
+            EXPECT_CALL(*handler, handle_input(ButtonDownEvent(0, 0))).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
         }
     } client_config;
     launch_client_process(client_config);
@@ -474,44 +403,26 @@
 
 namespace
 {
-struct StubViewableArea : public mg::ViewableArea
-{
-    StubViewableArea(int width, int height) :
-        width(width),
-        height(height),
-        x(0),
-        y(0)
-    {
-    }
-    
-    geom::Rectangle view_area() const
-    {
-        return geom::Rectangle{geom::Point{x, y},
-            geom::Size{width, height}};
-    }
-    
-    geom::Width const width;
-    geom::Height const height;
-    geom::X const x;
-    geom::Y const y;
-};
-
-typedef std::map<std::string, geom::Point> PositionList;
+typedef std::map<std::string, geom::Rectangle> GeometryList;
 
 struct StaticPlacementStrategy : public msh::PlacementStrategy
 {
-    StaticPlacementStrategy(PositionList positions)
-        : surface_positions_by_name(positions)
+    StaticPlacementStrategy(GeometryList const& positions)
+        : surface_geometry_by_name(positions)
     {
     }
 
     msh::SurfaceCreationParameters place(msh::SurfaceCreationParameters const& request_parameters)
     {
         auto placed = request_parameters;
-        placed.top_left = surface_positions_by_name[request_parameters.name];
+        auto geometry = surface_geometry_by_name[request_parameters.name];
+
+        placed.top_left = geometry.top_left;
+        placed.size = geometry.size;
+        
         return placed;
     }
-    PositionList surface_positions_by_name;
+    GeometryList surface_geometry_by_name;
 };
 
 }
@@ -520,115 +431,77 @@
 {
     using namespace ::testing;
     
-    int const screen_width = 1000;
-    int const screen_height = 800;
-    int const client_width = screen_width/2;
-    int const client_height = screen_height;
-    std::string const surface1_name = "1";
-    std::string const surface2_name = "2";
+    static int const screen_width = 1000;
+    static int const screen_height = 800;
+    static int const client_height = screen_width/2;
+    static int const client_width = screen_width/2;
+    static std::string const test_client_1 = "1";
+    static std::string const test_client_2 = "2";
     
-    PositionList positions;
-    positions[surface1_name] = geom::Point{geom::X{0}, geom::Y{0}};
-    positions[surface2_name] = geom::Point{geom::X{screen_width/2}, geom::Y{0}};
-
-    struct TestServerConfiguration : FakeInputServerConfiguration
+    struct ServerConfiguration : mtf::InputTestingServerConfiguration
     {
-        TestServerConfiguration(int screen_width, int screen_height, PositionList positions)
-            : screen_width(screen_width),
-              screen_height(screen_height),
-              positions(positions),
-              clients_ready(0)
-        {
-        }
-
-        std::shared_ptr<mg::ViewableArea> the_viewable_area() override
-        {
-            return std::make_shared<StubViewableArea>(screen_width, screen_height);
-        }
         std::shared_ptr<msh::PlacementStrategy> the_shell_placement_strategy() override
         {
+            static GeometryList positions;
+            positions[test_client_1] = geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
+                geom::Size{geom::Width{client_width}, geom::Height{client_height}}};
+            positions[test_client_2] = geom::Rectangle{geom::Point{geom::X{screen_width/2}, geom::Y{0}},
+                geom::Size{geom::Width{client_width}, geom::Height{client_height}}};
+
             return std::make_shared<StaticPlacementStrategy>(positions);
         }
+        
+        geom::Rectangle the_screen_geometry() override
+        {
+            return geom::Rectangle{geom::Point{geom::X{0}, geom::Y{0}},
+                    geom::Size{geom::Width{screen_width}, geom::Height{screen_height}}};
+        }
 
-        void inject_input_after_focus() override
+        void inject_input() override
         {
-            clients_ready++;
-            if (clients_ready != 2) // We wait until both clients have connected and registered with the input stack.
-                return;
-            
+            wait_until_client_appears(test_client_1);
+            wait_until_client_appears(test_client_2);
             // In the bounds of the first surface
             fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2-1, 0));
             // In the bounds of the second surface
             fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(screen_width/2, 0));
         }
-        int screen_width, screen_height;
-        PositionList positions;
-
-        int clients_ready;
-    } server_config(screen_width, screen_height, positions);
+    } server_config;
     
     launch_server_process(server_config);
     
-    MirSurfaceParameters const surface1_params =
-        {
-            surface1_name.c_str(),
-            client_width, client_height,
-            mir_pixel_format_abgr_8888,
-            mir_buffer_usage_hardware
-        };    
-    MirSurfaceParameters const surface2_params =
-        {
-            surface2_name.c_str(),
-            client_width, client_height,
-            mir_pixel_format_abgr_8888,
-            mir_buffer_usage_hardware
-        };
-    struct ParameterizedClient : InputReceivingClient
+    struct InputClientOne : InputClient
     {
-        ParameterizedClient(MirSurfaceParameters params, int events_to_expect) : 
-            InputReceivingClient(events_to_expect),
-            params(params)
+        InputClientOne()
+           : InputClient(test_client_1)
         {
         }
         
-        MirSurfaceParameters parameters() override
+        void expect_input(mt::WaitCondition& events_received) override
         {
-            return params;
+            InSequence seq;
+            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1);
+            EXPECT_CALL(*handler, handle_input(MotionEventWithPosition(client_width - 1, 0))).Times(1);
+            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
         }
+    } client_1;
 
-        MirSurfaceParameters params;
-    };
-    struct InputClientOne : ParameterizedClient
-    {
-        InputClientOne(MirSurfaceParameters params) :
-            ParameterizedClient(params, 3)
-        {
-        }
-        
-        void expect_input() override
-        {
-            InSequence seq;
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1).WillOnce(Return(true));
-            EXPECT_CALL(*handler, handle_input(
-                MotionEventWithPosition(params.width - 1, 0))).Times(1).WillOnce(Return(true));
-            EXPECT_CALL(*handler, handle_input(HoverExitEvent())).Times(1).WillOnce(Return(true));
-        }
-    } client_1(surface1_params);
-    struct InputClientTwo : ParameterizedClient
-    {
-        InputClientTwo(MirSurfaceParameters params) :
-            ParameterizedClient(params, 2)
-        {
-        }
-        
-        void expect_input() override
-        {
-            InSequence seq;
-            EXPECT_CALL(*handler, handle_input(HoverEnterEvent())).Times(1).WillOnce(Return(true));
-            EXPECT_CALL(*handler, handle_input(
-                MotionEventWithPosition(params.width - 1, 0))).Times(1).WillOnce(Return(true));
-        }
-    } client_2(surface2_params);
+    struct InputClientTwo : InputClient
+    {
+        InputClientTwo()
+            : InputClient(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, 0))).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+        }
+    } client_2;
 
     launch_client_process(client_1);
     launch_client_process(client_2);

=== modified file 'tests/mir_test_framework/CMakeLists.txt'
--- tests/mir_test_framework/CMakeLists.txt	2013-04-24 05:22:20 +0000
+++ tests/mir_test_framework/CMakeLists.txt	2013-06-14 16:12:27 +0000
@@ -8,6 +8,7 @@
   TEST_FRAMEWORK_SRCS
 
   testing_server_options.cpp
+  input_testing_server_options.cpp
   testing_process_manager.cpp
   display_server_test_fixture.cpp
   process.cpp
@@ -20,6 +21,7 @@
 add_library(
   mir-test-framework STATIC
   ${TEST_FRAMEWORK_SRCS})
+uses_android_input(mir-test-framework)
 
 target_link_libraries(
   mir-test-framework

=== added file 'tests/mir_test_framework/input_testing_server_options.cpp'
--- tests/mir_test_framework/input_testing_server_options.cpp	1970-01-01 00:00:00 +0000
+++ tests/mir_test_framework/input_testing_server_options.cpp	2013-06-14 16:12:27 +0000
@@ -0,0 +1,247 @@
+/*
+ * 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_test_framework/input_testing_server_configuration.h"
+
+#include "mir/input/surface_target.h"
+#include "mir/surfaces/input_registrar.h"
+#include "mir/graphics/display.h"
+#include "mir/graphics/viewable_area.h"
+
+#include "mir_test/fake_event_hub.h"
+#include "mir_test/fake_event_hub_input_configuration.h"
+
+#include <boost/throw_exception.hpp>
+
+#include <functional>
+#include <stdexcept>
+
+#include <time.h>
+
+namespace mtf = mir_test_framework;
+
+namespace ms = mir::surfaces;
+namespace mg = mir::graphics;
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace geom = mir::geometry;
+namespace mtd = mir::test::doubles;
+
+namespace
+{
+class SurfaceReadinessListener
+{
+public:
+    virtual ~SurfaceReadinessListener() = default;
+    
+    virtual void surface_ready_for_input(std::string const& surface_name) = 0;
+    virtual void surface_finished_for_input(std::string const& surface_name) = 0;
+
+protected:
+    SurfaceReadinessListener() = default;
+    SurfaceReadinessListener(SurfaceReadinessListener const&) = delete;
+    SurfaceReadinessListener& operator=(SurfaceReadinessListener const&) = delete;
+};
+
+class ProxyInputRegistrar : public ms::InputRegistrar
+{
+public:
+    ProxyInputRegistrar(std::shared_ptr<ms::InputRegistrar> const underlying_registrar,
+                        std::shared_ptr<SurfaceReadinessListener> const listener)
+        : underlying_registrar(underlying_registrar),
+          listener(listener)
+    {   
+    }
+
+    ~ProxyInputRegistrar() noexcept(true) = default;
+    
+    void input_surface_opened(std::shared_ptr<mi::SurfaceTarget> const& opened_surface)
+    {
+        underlying_registrar->input_surface_opened(opened_surface);
+        listener->surface_ready_for_input(opened_surface->name());
+    }
+    void input_surface_closed(std::shared_ptr<mi::SurfaceTarget> const& closed_surface)
+    {
+        underlying_registrar->input_surface_closed(closed_surface);
+        listener->surface_finished_for_input(closed_surface->name());
+    }
+
+private:
+    std::shared_ptr<ms::InputRegistrar> const underlying_registrar;
+    std::shared_ptr<SurfaceReadinessListener> const listener;
+};
+
+struct SizedViewArea : public mg::ViewableArea
+{
+    SizedViewArea(geom::Rectangle const& area)
+        : area(area)
+    {
+    }
+    geom::Rectangle view_area() const override
+    {
+        return area;
+    }
+    geom::Rectangle area;
+};
+}
+
+mtf::InputTestingServerConfiguration::InputTestingServerConfiguration()
+{
+}
+
+void mtf::InputTestingServerConfiguration::exec()
+{
+    input_injection_thread = std::thread(std::mem_fn(&mtf::InputTestingServerConfiguration::inject_input), this);
+}
+
+void mtf::InputTestingServerConfiguration::on_exit()
+{
+    input_injection_thread.join();
+}
+
+std::shared_ptr<mi::InputConfiguration> mtf::InputTestingServerConfiguration::the_input_configuration()
+{
+    if (!input_configuration)
+    {
+        std::shared_ptr<mi::CursorListener> null_cursor_listener{nullptr};
+
+        input_configuration = std::make_shared<mtd::FakeEventHubInputConfiguration>(the_event_filters(),
+            the_display(),
+            null_cursor_listener,
+            the_input_report());
+        fake_event_hub = input_configuration->the_fake_event_hub();
+
+        fake_event_hub->synthesize_builtin_keyboard_added();
+        fake_event_hub->synthesize_builtin_cursor_added();
+        fake_event_hub->synthesize_device_scan_complete();
+    }
+    
+    return input_configuration;
+}
+
+std::shared_ptr<ms::InputRegistrar> mtf::InputTestingServerConfiguration::the_input_registrar()
+{
+    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 surface_ready_for_input(std::string const& surface_name)
+        {
+            std::unique_lock<std::mutex> lg(lifecycle_lock);
+            client_lifecycles[surface_name] = mtf::ClientLifecycleState::appeared;
+            lifecycle_condition.notify_all();
+        }
+
+        void surface_finished_for_input(std::string const& surface_name)
+        {
+            std::unique_lock<std::mutex> lg(lifecycle_lock);
+            client_lifecycles[surface_name] = mtf::ClientLifecycleState::vanished;
+            lifecycle_condition.notify_all();
+        }
+        std::mutex &lifecycle_lock;
+        std::condition_variable &lifecycle_condition;
+        std::map<std::string, mtf::ClientLifecycleState> &client_lifecycles;
+    };
+    
+    if (!input_registrar)
+    {
+        auto registrar_listener = std::make_shared<LifecycleTracker>(lifecycle_lock,
+            lifecycle_condition,
+            client_lifecycles);
+        input_registrar = std::make_shared<ProxyInputRegistrar>(the_input_configuration()->the_input_registrar(),
+            registrar_listener);
+    }
+
+    return input_registrar;
+}
+
+geom::Rectangle mtf::InputTestingServerConfiguration::the_screen_geometry()
+{
+    static geom::Rectangle const default_geometry{geom::Point{geom::X{0}, geom::Y{0}},
+        geom::Size{geom::Width{1600}, geom::Height{1600}}};
+    return default_geometry;
+}
+
+std::shared_ptr<mg::ViewableArea> mtf::InputTestingServerConfiguration::the_viewable_area()
+{
+    if (!view_area)
+        view_area = std::make_shared<SizedViewArea>(the_screen_geometry());
+    return view_area;
+}
+
+void mtf::InputTestingServerConfiguration::wait_until_client_appears(std::string const& surface_name)
+{
+    std::unique_lock<std::mutex> lg(lifecycle_lock);
+    
+    time_t end_time = ::time(NULL) + 60;
+    
+    if (client_lifecycles[surface_name] == appeared)
+    {
+        return;
+    }
+    else if (client_lifecycles[surface_name] == vanished)
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Waiting for a client (" + surface_name + ") to appear but it has already vanished"));
+    }
+    else
+    {
+        while (::time(NULL) < end_time)
+        {
+            lifecycle_condition.wait_for(lg, std::chrono::seconds(60));
+            if (client_lifecycles[surface_name] == appeared)
+            {
+                return;
+            }
+        }
+        BOOST_THROW_EXCEPTION(std::runtime_error("Timed out waiting for client (" + surface_name + ") to appear"));
+     }
+}
+
+void mtf::InputTestingServerConfiguration::wait_until_client_vanishes(std::string const& surface_name)
+{
+    std::unique_lock<std::mutex> lg(lifecycle_lock);
+
+    time_t end_time = ::time(NULL) + 60;
+    
+    if (client_lifecycles[surface_name] == vanished)
+    {
+        return;
+    }
+    else if (client_lifecycles[surface_name] == starting)
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Waiting for a client (" + surface_name + ") to vanish but it has not started"));
+    }
+    else
+    {
+        while (::time(NULL) < end_time)
+        {
+            lifecycle_condition.wait_for(lg, std::chrono::seconds(60));
+            if (client_lifecycles[surface_name] == vanished)
+            {
+                return;
+            }
+        }
+        BOOST_THROW_EXCEPTION(std::runtime_error("Timed out waiting for client (" + surface_name + ") to vanish"));
+     }
+}