Merge lp:~dandrader/qtmir/oneUpDownPerEvent-lp1437357 into lp:qtmir

[Daniel d'Andrada]

When synthesizing touch releases for absent touches, send them in separate events

As there can be only one touch pressed or released per event.

* Are there any related MPs required for this MP to build/function as expected? Please list.
No.

* Did you perform an exploratory manual test run of your code change and any related functionality?
Yes.

* If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?
Not applicable.

[lp:~dandrader/qtmir/oneUpDownPerEvent-lp1437357]

330. By Daniel d'Andrada on 2015-04-01

Remove leftover

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:330
http://jenkins.qa.ubuntu.com/job/qtmir-ci/245/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/96
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/96
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/96/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/245/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

Would catching the exception be easier than all this work?
And is there a Mir bug so we can keep track of Mir fixing their input stream to us? All this event stream sanitizing should be unnecessary.

+#include "../../common/debughelpers.h"
better to include ../../common as a source of headers

-Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input")
+Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input", QtWarningMsg)
what does this give us?

Was unable to reproduce a crash on devel-proposed, but I find no regressions while testing it

review: Needs Fixing

[lp:~dandrader/qtmir/oneUpDownPerEvent-lp1437357]

331. By Daniel d'Andrada on 2015-04-16

add src/common to platform/mirserver include dirs

[Daniel d'Andrada (dandrader)]

On 16/04/15 08:22, Gerry Boland wrote:
> Review: Needs Fixing
>
> Would catching the exception be easier than all this work?

I don't see the point. The mir exception is thrown when we try to send a
MirEvent containing more than one touch press or release. We shouldn't
be doing that in the first place.

> And is there a Mir bug so we can keep track of Mir fixing their input stream to us? All this event stream sanitizing should be unnecessary.

There's this one at least: https://bugs.launchpad.net/mir/+bug/1439285

>
>
> +#include "../../common/debughelpers.h"
> better to include ../../common as a source of headers
Done.
> -Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input")
> +Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input", QtWarningMsg)
> what does this give us?
It means that by default only warnings or more severe message types
(criticals) will be logged. So we won't spam logs with debug messages by
default. This is particularly important here as I added a debug messages
for every single input event coming or leaving QtEventFeeder.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:331
http://jenkins.qa.ubuntu.com/job/qtmir-ci/249/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/100
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/100
        deb: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/100/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/249/rebuild

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

LGTM, thank you

review: Approve

=== modified file 'src/common/debughelpers.cpp'
--- src/common/debughelpers.cpp	2015-02-19 23:03:14 +0000
+++ src/common/debughelpers.cpp	2015-04-16 13:38:31 +0000
@@ -207,3 +207,50 @@
         return "???";
     }
 }
+
+QString mirTouchEventToString(MirTouchInputEvent const* event)
+{
+    const int pointerCount = mir_touch_input_event_get_touch_count(event);
+
+    QString string("MirTouchInputEvent(");
+
+    for (int i = 0; i < pointerCount; ++i) {
+
+        if (i > 0) {
+            string.append(",");
+        }
+
+        MirTouchInputEventTouchAction touchAction = mir_touch_input_event_get_touch_action(event, i);
+
+        QString touchStr = QString("(id=%1,action=%2,x=%3,y=%4)")
+            .arg(mir_touch_input_event_get_touch_id(event, i))
+            .arg(mirTouchActionToString(touchAction))
+            .arg(mir_touch_input_event_get_touch_axis_value(event, i, mir_touch_input_axis_x))
+            .arg(mir_touch_input_event_get_touch_axis_value(event, i, mir_touch_input_axis_y));
+
+        string.append(touchStr);
+    }
+
+    string.append(")");
+
+    return string;
+}
+
+const char *mirTouchActionToString(MirTouchInputEventTouchAction touchAction)
+{
+    switch (touchAction)
+    {
+    case mir_touch_input_event_action_up:
+        return "up";
+        break;
+    case mir_touch_input_event_action_down:
+        return "down";
+        break;
+    case mir_touch_input_event_action_change:
+        return "change";
+        break;
+    default:
+        return "???";
+        break;
+    }
+}

=== modified file 'src/common/debughelpers.h'
--- src/common/debughelpers.h	2014-08-27 11:51:28 +0000
+++ src/common/debughelpers.h	2015-04-16 13:38:31 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-2015 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
@@ -20,6 +20,7 @@
 #include <QString>
 
 #include <mir_toolkit/common.h>
+#include <mir_toolkit/events/input/input_event.h>
 
 class QTouchEvent;
 
@@ -35,4 +36,7 @@
 
 const char *applicationStateToStr(int state);
 
+QString mirTouchEventToString(MirTouchInputEvent const* event);
+const char *mirTouchActionToString(MirTouchInputEventTouchAction touchAction);
+
 #endif // UBUNTUGESTURES_DEBUG_HELPER_H

=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2015-01-28 14:25:36 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2015-04-16 13:38:31 +0000
@@ -18,9 +18,11 @@
 endforeach(item ${Qt5Gui_PRIVATE_INCLUDE_DIRS})
 
 include_directories(
+    ${CMAKE_SOURCE_DIR}/src/common
+
     ${MIRCOMMON_INCLUDE_DIRS}
     ${MIRSERVER_INCLUDE_DIRS}
-    
+
     ${URL_DISPATCHER_INCLUDE_DIRS}
     ${PROTOBUF_INCLUDE_DIRS}
     ${EGL_INCLUDE_DIRS}
@@ -37,7 +39,7 @@
 add_definitions(-DBYTE_ORDER=__BYTE_ORDER)
 
 set(MIRSERVER_QPA_PLUGIN_SRC
-    ../../common/debughelpers.cpp
+    ${CMAKE_SOURCE_DIR}/src/common/debughelpers.cpp
     mirshell.cpp
     qteventfeeder.cpp
     plugin.cpp
@@ -74,7 +76,7 @@
     ${EGL_LDFLAGS}
     ${GL_LIBRARIES}
     ${LTTNG_LIBRARIES}
-    
+
     ${QT5PLATFORM_SUPPORT_LDFLAGS}
     # TODO Qt5Platform support LDFLAGS dont provide actual required ldflags...
     # I found these were needed...perhaps there is some way to query qmake/qconfig?

=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2015-02-19 23:03:14 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2015-04-16 13:38:31 +0000
@@ -30,7 +30,10 @@
 
 #include <QDebug>
 
-Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input")
+// common dir
+#include <debughelpers.h>
+
+Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input", QtWarningMsg)
 
 // XKB Keysyms which do not map directly to Qt types (i.e. Unicode points)
 static const uint32_t KeyTable[] = {
@@ -355,6 +358,7 @@
         return;
 
     auto tev = mir_input_event_get_touch_input_event(event);
+    qCDebug(QTMIR_MIR_INPUT) << "Received" << qPrintable(mirTouchEventToString(tev));
 
     // FIXME(loicm) Max pressure is device specific. That one is for the Samsung Galaxy Nexus. That
     //     needs to be fixed as soon as the compat input lib adds query support.
@@ -398,9 +402,10 @@
 
     // Qt needs a happy, sane stream of touch events. So let's make sure we're not forwarding
     // any insanity.
-    validateTouches(touchPoints);
+    validateTouches(mir_input_event_get_event_time(event) / 1000000, touchPoints);
 
     // Touch event propagation.
+    qCDebug(QTMIR_MIR_INPUT) << "Sending to Qt" << qPrintable(touchesToString(touchPoints));
     mQtWindowSystem->handleTouchEvent(
         //scales down the nsec_t (int64) to fit a ulong, precision lost but time difference suitable
         mir_input_event_get_event_time(event) / 1000000,
@@ -429,7 +434,8 @@
     Q_UNUSED(when);
 }
 
-void QtEventFeeder::validateTouches(QList<QWindowSystemInterface::TouchPoint> &touchPoints)
+void QtEventFeeder::validateTouches(ulong timestamp,
+        QList<QWindowSystemInterface::TouchPoint> &touchPoints)
 {
     QSet<int> updatedTouches;
 
@@ -446,21 +452,45 @@
         }
     }
 
-    // Release all unmentioned touches.
-    {
-        QHash<int, QWindowSystemInterface::TouchPoint>::iterator it = mActiveTouches.begin();
-        while (it != mActiveTouches.end()) {
-            if (!updatedTouches.contains(it.key())) {
-                qCWarning(QTMIR_MIR_INPUT)
-                    << "There's a touch (id =" << it.key() << ") missing. Releasing it.";
-                it.value().state = Qt::TouchPointReleased;
-                touchPoints.append(it.value());
-                it = mActiveTouches.erase(it);
-            } else {
-                ++it;
-            }
-        }
-    }
+    // Release all unmentioned touches, one by one.
+    QHash<int, QWindowSystemInterface::TouchPoint>::iterator it = mActiveTouches.begin();
+    while (it != mActiveTouches.end()) {
+        if (!updatedTouches.contains(it.key())) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "There's a touch (id =" << it.key() << ") missing. Releasing it.";
+            sendActiveTouchRelease(timestamp, it.key());
+            it = mActiveTouches.erase(it);
+        } else {
+            ++it;
+        }
+    }
+
+    // update mActiveTouches
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        auto &touchPoint = touchPoints.at(i);
+        if (touchPoint.state == Qt::TouchPointReleased) {
+            mActiveTouches.remove(touchPoint.id);
+        } else {
+            mActiveTouches[touchPoint.id] = touchPoint;
+        }
+    }
+}
+
+void QtEventFeeder::sendActiveTouchRelease(ulong timestamp, int id)
+{
+    QList<QWindowSystemInterface::TouchPoint> touchPoints = mActiveTouches.values();
+
+    for (int i = 0; i < touchPoints.count(); ++i) {
+        QWindowSystemInterface::TouchPoint &touchPoint = touchPoints[i];
+        if (touchPoint.id == id) {
+            touchPoint.state = Qt::TouchPointReleased;
+        } else {
+            touchPoint.state = Qt::TouchPointStationary;
+        }
+    }
+
+    qCDebug(QTMIR_MIR_INPUT) << "Sending to Qt" << qPrintable(touchesToString(touchPoints));
+    mQtWindowSystem->handleTouchEvent(timestamp, mTouchDevice, touchPoints);
 }
 
 bool QtEventFeeder::validateTouch(QWindowSystemInterface::TouchPoint &touchPoint)
@@ -475,7 +505,6 @@
                 << "). Making it move instead.";
             touchPoint.state = Qt::TouchPointMoved;
         }
-        mActiveTouches[touchPoint.id] = touchPoint;
         break;
     case Qt::TouchPointMoved:
         if (!mActiveTouches.contains(touchPoint.id)) {
@@ -484,7 +513,6 @@
                 << "). Making it press instead.";
             touchPoint.state = Qt::TouchPointPressed;
         }
-        mActiveTouches[touchPoint.id] = touchPoint;
         break;
     case Qt::TouchPointStationary:
         if (!mActiveTouches.contains(touchPoint.id)) {
@@ -493,7 +521,6 @@
                 << "). Making it press instead.";
             touchPoint.state = Qt::TouchPointPressed;
         }
-        mActiveTouches[touchPoint.id] = touchPoint;
         break;
     case Qt::TouchPointReleased:
         if (!mActiveTouches.contains(touchPoint.id)) {
@@ -501,8 +528,6 @@
                 << "Would release a touch that wasn't pressed before (id =" << touchPoint.id
                 << "). Ignoring it.";
             ok = false;
-        } else {
-            mActiveTouches.remove(touchPoint.id);
         }
         break;
     default:
@@ -511,3 +536,21 @@
 
     return ok;
 }
+
+QString QtEventFeeder::touchesToString(const QList<struct QWindowSystemInterface::TouchPoint> &points)
+{
+    QString result;
+    for (int i = 0; i < points.count(); ++i) {
+        if (i > 0) {
+            result.append(",");
+        }
+        const struct QWindowSystemInterface::TouchPoint &point = points.at(i);
+        result.append(QString("(id=%1,state=%2,normalPosition=(%3,%4))")
+            .arg(point.id)
+            .arg(touchPointStateToString(point.state))
+            .arg(point.normalPosition.x())
+            .arg(point.normalPosition.y())
+            );
+    }
+    return result;
+}

=== modified file 'src/platforms/mirserver/qteventfeeder.h'
--- src/platforms/mirserver/qteventfeeder.h	2015-02-19 23:03:14 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2015-04-16 13:38:31 +0000
@@ -71,8 +71,11 @@
     void dispatchKey(MirInputEvent const* event);
     void dispatchTouch(MirInputEvent const* event);
     void dispatchPointer(MirInputEvent const* event);
-    void validateTouches(QList<QWindowSystemInterface::TouchPoint> &touchPoints);
+    void validateTouches(ulong timestamp, QList<QWindowSystemInterface::TouchPoint> &touchPoints);
     bool validateTouch(QWindowSystemInterface::TouchPoint &touchPoint);
+    void sendActiveTouchRelease(ulong timestamp, int id);
+
+    QString touchesToString(const QList<struct QWindowSystemInterface::TouchPoint> &points);
 
     QTouchDevice *mTouchDevice;
     QtWindowSystemInterface *mQtWindowSystem;

=== modified file 'tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h'
--- tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2015-02-19 23:03:14 +0000
+++ tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2015-04-16 13:38:31 +0000
@@ -50,6 +50,11 @@
     return arg.state == Qt::TouchPointReleased;
 }
 
+MATCHER(IsStationary, std::string(negation ? "isn't" : "is") + " stationary")
+{
+    return arg.state == Qt::TouchPointStationary;
+}
+
 MATCHER(StateIsMoved, "state " + std::string(negation ? "isn't" : "is") + " 'moved'")
 {
     return arg.state == Qt::TouchPointMoved;

=== modified file 'tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp'
--- tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2015-02-19 23:03:14 +0000
+++ tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2015-04-16 13:38:31 +0000
@@ -40,10 +40,12 @@
 
 // own gmock extensions
 using ::testing::IsPressed;
+using ::testing::IsStationary;
 using ::testing::IsReleased;
 using ::testing::HasId;
 using ::testing::StateIsMoved;
 
+// used by google mock in error messages
 void PrintTo(const struct QWindowSystemInterface::TouchPoint& touchPoint, ::std::ostream* os) {
     *os << "TouchPoint("
         << "id=" << touchPoint.id
@@ -51,6 +53,12 @@
         << ")";
 }
 
+::std::ostream& operator<<(::std::ostream& os, QTouchDevice*) {
+    // actually don't care about its contents. Just to avoit having a raw
+    // pointer address being printed in google mock error messages.
+    return os << "QTouchDevice*";
+}
+
 class QtEventFeederTest : public ::testing::Test {
 protected:
     void SetUp() override;
@@ -96,7 +104,7 @@
    Then, Mir sends a MirEvent([touch(id=1,state=pressed)]). In MirEvents, every single active touch
    point must be listed in the event even if it didn't change at all in the meantime. So that's a bug.
    But instead of crashing or forwarding the bogus event stream down to Qt, QtEventFeeder should attempt
-   to fix the situation by synthesizing a touch[id=1,state=released] to be send along with the
+   to fix the situation by synthesizing a touch[id=0,state=released] to be send along with the
    touch(id=1,state=pressed) it got. So that Qt receives a correct touch event stream.
  */
 TEST_F(QtEventFeederTest, GenerateMissingTouchEnd)
@@ -126,22 +134,133 @@
 
     setIrrelevantMockWindowSystemExpectations();
 
-    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(2),
-                                                              Contains(AllOf(HasId(0),IsReleased())),
-                                                              Contains(AllOf(HasId(1),IsPressed()))
-                                                             ),_)).Times(1);
-
-    mirEvent.type = mir_event_type_motion;
-    mirEvent.motion.pointer_count = 1;
-    mirEvent.motion.pointer_coordinates[0].id = 1;
-    mirEvent.motion.pointer_coordinates[0].x = 20;
-    mirEvent.motion.pointer_coordinates[0].y = 20;
-    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
-    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
-    mirEvent.motion.pointer_coordinates[0].pressure = 10;
-    mirEvent.motion.action = mir_motion_action_down;
-    mirEvent.motion.event_time = 125 * 1000000;
-
+    // There can be only one pressed or released touch per event
+    {
+        InSequence sequence;
+
+        EXPECT_CALL(*mockWindowSystem,
+                    handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                               Contains(AllOf(HasId(0),IsReleased()))
+                                               ),_)).Times(1);
+
+        EXPECT_CALL(*mockWindowSystem,
+                    handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                               Contains(AllOf(HasId(1),IsPressed()))
+                                               ),_)).Times(1);
+    }
+
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.pointer_coordinates[0].id = 1;
+    mirEvent.motion.pointer_coordinates[0].x = 20;
+    mirEvent.motion.pointer_coordinates[0].y = 20;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.action = mir_motion_action_down;
+    mirEvent.motion.event_time = 125 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+}
+
+TEST_F(QtEventFeederTest, GenerateMissingTouchEnd2)
+{
+
+    setIrrelevantMockWindowSystemExpectations();
+
+
+    MirEvent mirEvent;
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.action = mir_motion_action_down;
+    mirEvent.motion.pointer_coordinates[0].id = 0;
+    mirEvent.motion.pointer_coordinates[0].x = 10;
+    mirEvent.motion.pointer_coordinates[0].y = 10;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.event_time = 123 * 1000000;
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                                              Contains(AllOf(HasId(0),
+                                                                             IsPressed()))),_)).Times(1);
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+
+    // ---
+
+    setIrrelevantMockWindowSystemExpectations();
+
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 2;
+    mirEvent.motion.action = mir_motion_action_pointer_down | (1 /*pointer index*/ << 8 /*shift*/);
+    mirEvent.motion.pointer_coordinates[0].id = 0;
+    mirEvent.motion.pointer_coordinates[0].x = 10;
+    mirEvent.motion.pointer_coordinates[0].y = 10;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.pointer_coordinates[1].id = 1;
+    mirEvent.motion.pointer_coordinates[1].x = 20;
+    mirEvent.motion.pointer_coordinates[1].y = 20;
+    mirEvent.motion.pointer_coordinates[1].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[1].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[1].pressure = 10;
+    mirEvent.motion.event_time = 124 * 1000000;
+
+    EXPECT_CALL(*mockWindowSystem,
+        handleTouchEvent(_,_,AllOf(SizeIs(2),
+                                   Contains(AllOf(HasId(0), StateIsMoved())),
+                                   Contains(AllOf(HasId(1), IsPressed()))
+                                   ),_)).Times(1);
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+
+    // ---
+
+    setIrrelevantMockWindowSystemExpectations();
+
+    // touch 0 disappeared and touch 2 got pressed
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 2;
+    mirEvent.motion.action = mir_motion_action_pointer_down | (1 /*pointer index*/ << 8 /*shift*/);
+    mirEvent.motion.pointer_coordinates[0].id = 1;
+    mirEvent.motion.pointer_coordinates[0].x = 20;
+    mirEvent.motion.pointer_coordinates[0].y = 20;
+    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[0].pressure = 10;
+    mirEvent.motion.pointer_coordinates[1].id = 2;
+    mirEvent.motion.pointer_coordinates[1].x = 30;
+    mirEvent.motion.pointer_coordinates[1].y = 30;
+    mirEvent.motion.pointer_coordinates[1].touch_major = 1;
+    mirEvent.motion.pointer_coordinates[1].touch_minor = 1;
+    mirEvent.motion.pointer_coordinates[1].pressure = 10;
+    mirEvent.motion.event_time = 125 * 1000000;
+
+    // There can be only one pressed or released touch per event
+    {
+        InSequence sequence;
+
+        // first release touch 0
+        EXPECT_CALL(*mockWindowSystem,
+            handleTouchEvent(_,_,AllOf(SizeIs(2),
+                                       Contains(AllOf(HasId(0), IsReleased())),
+                                       Contains(AllOf(HasId(1), IsStationary()))
+                                       ),_)).Times(1);
+
+        // then press touch 2
+        EXPECT_CALL(*mockWindowSystem,
+            handleTouchEvent(_,_,AllOf(SizeIs(2),
+                                       Contains(AllOf(HasId(1), StateIsMoved())),
+                                       Contains(AllOf(HasId(2), IsPressed()))
+                                       ),_)).Times(1);
+
+    }
     qtEventFeeder->dispatch(mirEvent);
 
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
@@ -192,4 +311,3 @@
 
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
 }
-