Merge lp:~andreas-pokorny/mir/fix-1531517-0.18 into lp:mir/0.18

[Andreas Pokorny]

Never encode more than one action per event

Android InputTransport has only one action parameter per event. Within that the contact that caused the action is also encoded. So until we replace or extend the input transport protocol, we have to split up MirEvents, to not lose touch up/down changes.
Additionally in this version of the fix. also a recent lp:mir cleanup that affected the tool type encoding of pointer events.

Similar to the change in lp:mir - but this fix also pulls in some clenaups in pointer event sending.

[Kevin DuBois (kdub)]

I'm guessing that we are going to release this? if so, we should bump MIR_VERSION_PATCH from 0 to 1.

review: Needs Fixing

[Kevin DuBois (kdub)]

l35: stray comment was added.

other than that, lgtm

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-12-03 16:20:03 +0000
+++ CMakeLists.txt	2016-01-15 11:15:53 +0000
@@ -28,7 +28,7 @@
 
 set(MIR_VERSION_MAJOR 0)
 set(MIR_VERSION_MINOR 18)
-set(MIR_VERSION_PATCH 0)
+set(MIR_VERSION_PATCH 1)
 
 add_definitions(-DMIR_VERSION_MAJOR=${MIR_VERSION_MAJOR})
 add_definitions(-DMIR_VERSION_MINOR=${MIR_VERSION_MINOR})

=== modified file 'src/client/symbols.map'
--- src/client/symbols.map	2015-12-07 12:35:30 +0000
+++ src/client/symbols.map	2016-01-15 11:15:53 +0000
@@ -253,3 +253,10 @@
     };
 } MIR_CLIENT_DETAIL_9;
 
+MIR_CLIENT_DETAIL_9v18v1 {
+  global:
+    extern "C++" { 
+      mir::input::android::android_pointer_action_from_mir*;
+    };
+} MIR_CLIENT_DETAIL_9v18;
+

=== modified file 'src/server/input/android/input_sender.cpp'
--- src/server/input/android/input_sender.cpp	2015-08-20 23:33:42 +0000
+++ src/server/input/android/input_sender.cpp	2016-01-15 11:15:53 +0000
@@ -180,16 +180,24 @@
 
     droidinput::status_t error_status;
 
-    auto event_time = mir_input_event_get_event_time(mir_event_get_input_event(&event.event));
-    if (event.event.type == mir_event_type_key)
+    auto input_event = mir_event_get_input_event(&event.event);
+    auto event_time = mir_input_event_get_event_time(input_event);
+    switch(mir_input_event_get_type(input_event))
     {
-        error_status = send_key_event(event.sequence_id, event.event.key);
+    case mir_input_event_type_key:
+        error_status = send_key_event(event.sequence_id, event.event);
         state.report->published_key_event(event.channel->server_fd(), event.sequence_id, event_time);
-    }
-    else
-    {
-        error_status = send_motion_event(event.sequence_id, event.event.motion);
-        state.report->published_motion_event(event.channel->server_fd(), event.sequence_id, event_time);
+        break;
+    case mir_input_event_type_pointer:
+        error_status = send_pointer_event(event.sequence_id, event.event);
+        state.report->published_motion_event(event.channel->server_fd(), event.sequence_id, event_time);
+        break;
+    case mir_input_event_type_touch:
+        error_status = send_touch_event(event.sequence_id, event.event);
+        state.report->published_motion_event(event.channel->server_fd(), event.sequence_id, event_time);
+        break;
+    default:
+        BOOST_THROW_EXCEPTION(std::runtime_error("unknown input event type"));
     }
 
     if (error_status == droidinput::OK)
@@ -213,6 +221,142 @@
     }
 }
 
+droidinput::status_t mia::InputSender::ActiveTransfer::send_key_event(uint32_t seq, MirEvent const& event)
+{
+    int32_t repeat_count = 0;
+    auto input_event = mir_event_get_input_event(&event);
+    auto key_event = mir_input_event_get_keyboard_event(input_event);
+    auto const android_action = mia::android_keyboard_action_from_mir(repeat_count, mir_keyboard_event_action(key_event));
+    std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
+    auto const flags = 0;
+    return publisher.publishKeyEvent(seq,
+                                     mir_input_event_get_device_id(input_event),
+                                     AINPUT_SOURCE_KEYBOARD,
+                                     android_action,
+                                     flags,
+                                     mir_keyboard_event_key_code(key_event),
+                                     mir_keyboard_event_scan_code(key_event),
+                                     mia::android_modifiers_from_mir(mir_keyboard_event_modifiers(key_event)),
+                                     repeat_count,
+                                     event.key.mac,
+                                     event_time,
+                                     event_time);
+}
+
+droidinput::status_t mia::InputSender::ActiveTransfer::send_touch_event(uint32_t seq, MirEvent const& event)
+{
+    droidinput::status_t ret = droidinput::OK;
+    droidinput::PointerCoords coords[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
+    droidinput::PointerProperties properties[MIR_INPUT_EVENT_MAX_POINTER_COUNT];
+    auto input_event = mir_event_get_input_event(&event);
+    auto touch = mir_input_event_get_touch_event(input_event);
+    std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
+    auto const x_offset = 0.0f;
+    auto const y_offset = 0.0f;
+    auto const x_precision = 0;
+    auto const y_precision = 0;
+    auto const flags = 0;
+    auto const edge_flags = 0;
+    auto const button_state = 0;
+
+    struct StateChange
+    {
+        int android_action;
+        size_t index;
+    };
+
+    std::vector<StateChange> state_changes;
+    for (size_t i = 0, e = mir_touch_event_point_count(touch); i != e; ++i)
+    {
+        auto const action = mir_touch_event_action(touch, i);
+        if (action == mir_touch_action_down)
+            state_changes.push_back(StateChange{AMOTION_EVENT_ACTION_DOWN, i});
+        if (action == mir_touch_action_up)
+            state_changes.push_back(StateChange{AMOTION_EVENT_ACTION_UP, i});
+    }
+
+    if (state_changes.empty())
+        state_changes.push_back(StateChange{AMOTION_EVENT_ACTION_MOVE, 0});
+
+    for (auto state_change : state_changes)
+    {
+        std::memset(&coords, 0, sizeof(coords));
+        std::memset(&properties, 0, sizeof(properties));
+
+        int contacts_in_event = 0;
+        int action_index = 0;
+        for (size_t i = 0, e = mir_touch_event_point_count(touch); i != e; ++i)
+        {
+            auto const action = mir_touch_event_action(touch, i);
+
+            if (i == state_change.index)
+                action_index = contacts_in_event;
+
+            // before a touch up state change got processed it is treated as 'change', skipped otherwise
+            // after a touch down state change got processed it is treated as 'change', skipped otherwise
+            if (i == state_change.index
+                || (i < state_change.index && action != mir_touch_action_up)
+                || (i > state_change.index && action != mir_touch_action_down))
+            {
+                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_X, mir_touch_event_axis_value(touch, i, mir_touch_axis_x));
+                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_Y, mir_touch_event_axis_value(touch, i, mir_touch_axis_y));
+                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, mir_touch_event_axis_value(touch, i, mir_touch_axis_touch_major));
+                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, mir_touch_event_axis_value(touch, i, mir_touch_axis_touch_minor));
+                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_SIZE, mir_touch_event_axis_value(touch, i, mir_touch_axis_size));
+                coords[contacts_in_event].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, mir_touch_event_axis_value(touch, i, mir_touch_axis_pressure));
+                properties[contacts_in_event].toolType = mia::android_tool_type_from_mir(mir_touch_event_tooltype(touch, i));
+                properties[contacts_in_event].id = mir_touch_event_id(touch, i);
+                ++contacts_in_event;
+            }
+        }
+
+        state_change.android_action |= (action_index << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
+
+        ret = publisher.publishMotionEvent(seq, mir_input_event_get_device_id(input_event), AINPUT_SOURCE_TOUCHSCREEN,
+                                           state_change.android_action, flags, edge_flags,
+                                           mia::android_modifiers_from_mir(mir_touch_event_modifiers(touch)),
+                                           button_state, x_offset, y_offset, x_precision, y_precision, event.motion.mac,
+                                           event_time, event_time, contacts_in_event, properties, coords);
+    }
+
+    return ret;
+}
+
+droidinput::status_t mia::InputSender::ActiveTransfer::send_pointer_event(uint32_t seq, MirEvent const& event)
+{
+    droidinput::PointerCoords pointer_coord;
+    droidinput::PointerProperties pointer_properties;
+    std::memset(&pointer_coord, 0, sizeof(pointer_coord));
+    std::memset(&pointer_properties, 0, sizeof(pointer_properties));
+
+    auto input_event = mir_event_get_input_event(&event);
+    auto pointer = mir_input_event_get_pointer_event(input_event);
+    pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_X, mir_pointer_event_axis_value(pointer, mir_pointer_axis_x));
+    pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_Y, mir_pointer_event_axis_value(pointer, mir_pointer_axis_y));
+    pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_HSCROLL, mir_pointer_event_axis_value(pointer, mir_pointer_axis_hscroll));
+    pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_VSCROLL, mir_pointer_event_axis_value(pointer, mir_pointer_axis_vscroll));
+    pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_RX, mir_pointer_event_axis_value(pointer, mir_pointer_axis_relative_x));
+    pointer_coord.setAxisValue(AMOTION_EVENT_AXIS_RY, mir_pointer_event_axis_value(pointer, mir_pointer_axis_relative_y));
+    pointer_properties.toolType = AMOTION_EVENT_TOOL_TYPE_MOUSE;
+    pointer_properties.id = 0;
+
+    std::chrono::nanoseconds const event_time{mir_input_event_get_event_time(input_event)};
+    auto const x_offset = 0.0f;
+    auto const y_offset = 0.0f;
+    auto const x_precision = 0;
+    auto const y_precision = 0;
+    auto const flags = 0;
+    auto const edge_flags = 0;
+    return publisher.publishMotionEvent(
+        seq, mir_input_event_get_device_id(input_event), AINPUT_SOURCE_MOUSE,
+        mia::android_pointer_action_from_mir(mir_pointer_event_action(pointer), mir_pointer_event_buttons(pointer)),
+        flags, edge_flags, mia::android_modifiers_from_mir(mir_pointer_event_modifiers(pointer)),
+        mia::android_pointer_buttons_from_mir(mir_pointer_event_buttons(pointer)), x_offset, y_offset, x_precision,
+        y_precision, event.motion.mac, event_time, event_time, 1, &pointer_properties, &pointer_coord);
+}
+
+
+
 mia::InputSender::ActiveTransfer::~ActiveTransfer()
 {
     unsubscribe();

=== modified file 'src/server/input/android/input_sender.h'
--- src/server/input/android/input_sender.h	2015-08-14 14:51:26 +0000
+++ src/server/input/android/input_sender.h	2016-01-15 11:15:53 +0000
@@ -97,6 +97,10 @@
 
     private:
         void on_finish_signal();
+        droidinput::status_t send_key_event(uint32_t sequence_id, MirEvent const& event);
+        droidinput::status_t send_touch_event(uint32_t sequence_id, MirEvent const& event);
+        droidinput::status_t send_pointer_event(uint32_t sequence_id, MirEvent const& event);
+
         void on_response_timeout();
         void update_timer();
         void cancel_timer();

=== modified file 'tests/unit-tests/input/android/test_android_input_sender.cpp'
--- tests/unit-tests/input/android/test_android_input_sender.cpp	2015-08-13 21:44:58 +0000
+++ tests/unit-tests/input/android/test_android_input_sender.cpp	2016-01-15 11:15:53 +0000
@@ -22,6 +22,7 @@
 #include "src/server/input/android/android_input_channel.h"
 #include "src/server/input/android/input_sender.h"
 #include "src/server/report/null_report_factory.h"
+#include "src/server/input/default_event_builder.h"
 
 #include "mir/test/doubles/stub_scene_surface.h"
 #include "mir/test/doubles/mock_input_surface.h"
@@ -36,6 +37,7 @@
 #include "androidfw/InputTransport.h"
 
 #include "mir/input/input_report.h"
+#include "mir/cookie_factory.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -92,6 +94,14 @@
     std::shared_ptr<ms::Observer> observer;
 };
 
+class StubCookieFactory : public mir::cookie::CookieFactory
+{
+public:
+    MirCookie timestamp_to_cookie(uint64_t const&) override { return {0, 0};}
+    bool attest_timestamp(MirCookie const&) override {return true;}
+    StubCookieFactory() = default;
+};
+
 }
 
 class AndroidInputSender : public ::testing::Test
@@ -101,7 +111,14 @@
     size_t const test_pointer_count = 2;
     float test_x_coord[2] = {12, 23};
     float test_y_coord[2] = {17, 9};
-    
+    MirTouchTooltype const tool = mir_touch_tooltype_finger;
+    float const pressure = 0.6f;
+    float const major = 8;
+    float const minor = 4;
+    float const size = 8;
+    StubCookieFactory cookie_factory;
+    mi::DefaultEventBuilder builder{MirInputDeviceId(), mt::fake_shared(cookie_factory)};
+
     AndroidInputSender()
        : key_event(mev::make_event(MirInputDeviceId(), std::chrono::nanoseconds(1), 0, mir_keyboard_action_down,
                                     7, test_scan_code, mir_input_event_modifier_none)),
@@ -394,3 +411,150 @@
     ::close(channel->client_fd());
     sender.send_event(*key_event, channel);
 }
+
+TEST_F(AndroidInputSender, encodes_multiple_touch_contact_downs_as_multiple_events)
+{
+    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
+    register_surface();
+
+    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
+    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_down, tool, 50, 60, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_down, tool, 80, 90, pressure, major, minor, size);
+
+    sender.send_event(*touch_ev_with_simultaneous_down, channel);
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
+    EXPECT_EQ(0, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(1, client_motion_event.getPointerCount());
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
+    EXPECT_EQ(1, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(4, client_motion_event.getPointerId(1));
+    EXPECT_EQ(2, client_motion_event.getPointerCount());
+}
+
+TEST_F(AndroidInputSender, encodes_multiple_touch_contact_downs_as_multiple_events_but_keeps_only_moved_contacts_in_place)
+{
+    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
+    register_surface();
+
+    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
+    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_down, tool, 50, 60, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_down, tool, 80, 90, pressure, major, minor, size);
+
+    sender.send_event(*touch_ev_with_simultaneous_down, channel);
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
+    EXPECT_EQ(0, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(3, client_motion_event.getPointerId(1));
+    EXPECT_EQ(2, client_motion_event.getPointerCount());
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
+    EXPECT_EQ(2, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(3, client_motion_event.getPointerId(1));
+    EXPECT_EQ(4, client_motion_event.getPointerId(2));
+    EXPECT_EQ(3, client_motion_event.getPointerCount());
+}
+
+TEST_F(AndroidInputSender, encodes_multiple_releases_in_several_events)
+{
+    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
+    register_surface();
+
+    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
+    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_up, tool, 50, 60, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_up, tool, 80, 90, pressure, major, minor, size);
+
+    sender.send_event(*touch_ev_with_simultaneous_down, channel);
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
+    EXPECT_EQ(0, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(3, client_motion_event.getPointerId(1));
+    EXPECT_EQ(4, client_motion_event.getPointerId(2));
+    EXPECT_EQ(3, client_motion_event.getPointerCount());
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
+    EXPECT_EQ(1, client_motion_event.getActionIndex());
+    EXPECT_EQ(3, client_motion_event.getPointerId(0));
+    EXPECT_EQ(4, client_motion_event.getPointerId(1));
+    EXPECT_EQ(2, client_motion_event.getPointerCount());
+}
+
+TEST_F(AndroidInputSender, encodes_combinations_of_up_and_down_one_by_one)
+{
+    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
+    register_surface();
+
+    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
+    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_up, tool, 50, 60, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_down, tool, 80, 90, pressure, major, minor, size);
+
+    sender.send_event(*touch_ev_with_simultaneous_down, channel);
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
+    EXPECT_EQ(0, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(3, client_motion_event.getPointerId(1));
+    EXPECT_EQ(2, client_motion_event.getPointerCount());
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
+    EXPECT_EQ(1, client_motion_event.getActionIndex());
+    EXPECT_EQ(3, client_motion_event.getPointerId(0));
+    EXPECT_EQ(4, client_motion_event.getPointerId(1));
+    EXPECT_EQ(2, client_motion_event.getPointerCount());
+}
+
+TEST_F(AndroidInputSender, encodes_combinations_of_down_and_up_one_by_one)
+{
+    // TODO When the rework of the transport encoding is finished we might want to revisit this decision
+    register_surface();
+
+    auto touch_ev_with_simultaneous_down = builder.touch_event(std::chrono::nanoseconds(86));
+    builder.add_touch(*touch_ev_with_simultaneous_down, 2, mir_touch_action_down, tool, 50, 60, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 3, mir_touch_action_change, tool, 10, 10, pressure, major, minor, size);
+    builder.add_touch(*touch_ev_with_simultaneous_down, 4, mir_touch_action_up, tool, 80, 90, pressure, major, minor, size);
+
+    sender.send_event(*touch_ev_with_simultaneous_down, channel);
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_DOWN, client_motion_event.getActionMasked());
+    EXPECT_EQ(0, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(3, client_motion_event.getPointerId(1));
+    EXPECT_EQ(4, client_motion_event.getPointerId(2));
+    EXPECT_EQ(3, client_motion_event.getPointerCount());
+
+    EXPECT_EQ(droidinput::OK, consumer.consume(&event_factory, true, std::chrono::nanoseconds(86), &seq, &event));
+    EXPECT_EQ(&client_motion_event, event);
+    EXPECT_EQ(AMOTION_EVENT_ACTION_UP, client_motion_event.getActionMasked());
+    EXPECT_EQ(2, client_motion_event.getActionIndex());
+    EXPECT_EQ(2, client_motion_event.getPointerId(0));
+    EXPECT_EQ(3, client_motion_event.getPointerId(1));
+    EXPECT_EQ(4, client_motion_event.getPointerId(2));
+    EXPECT_EQ(3, client_motion_event.getPointerCount());
+}