Merge lp:~dandrader/qtmir/missingTouchEnd-lp1295623 into lp:qtmir

[Daniel d'Andrada]

QtEventFeeder: validate touches before sending them to Qt

Make sure we send a tidy touch event stream to Qt as some of it
(QQuickWindow) is vulnerable to things like missing touch releases.

Also properly ignore unsupported motion event actions such as hovering.

Should fix https://launchpad.net/bugs/1295623

There's also this simple desktop application that exemplifies the situation that makes QQuickWindow stop generating mouse events, which is believed to be the cause of the bug above.
https://code.launchpad.net/~dandrader/+junk/touchToMouse

It captures raw mouse events and send synthesized touch events to the QQuickWindow out of them.
- Left button mouse clicks are translated to touch taps.
- Middle button mouse clicks are translated to touch taps as well with the difference that it omits the corresponding TouchEnd (thus emulating the bogus situation).

Left-click all rectangles and see that they happily blink. Then middle-click once a MouseArea. From that point onwards no mouse area will *ever* react to any left-click anymore. They get stuck forever. The touch area though will continue working normally.

I've made a patch for Qt to make QQuickWindow more robust, thus avoid entering in such bogus state, but I decided to solve it in the platform abstraction level as the qt patch is not a crowd pleaser.
https://codereview.qt-project.org/93002

* 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.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:240
http://jenkins.qa.ubuntu.com/job/qtmir-ci/40/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/40
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/40

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

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

Things I'd like clarified in a big comment in this code:
1. this is a workaround for a bug in Qt? If yes, please add the QTBUG number, plus a short textual description of that bug. It/when it gets fixed upstream, presumably we can remove this?
2. is this also processing slightly screwed up events from Mir so that they make sense to Qt? Other toolkits may also choke on this, so we should have a Mir bug on this topic - and reference it in this code too.

Code review:
+++ src/platforms/mirserver/qteventfeeder.h
+ class QtWindowSystem {
This is actually a interface, please call it QtWindowSystemInterface - hopefully it doesn't clash with Qt's defined one. Else QtMirWindowSystemInterface maybe? Is it a Window really? :)

+++ src/platforms/mirserver/qteventfeeder.cpp
+ class RealQtWindowSystem
if you do the above rename, then you can remove "Real" from the name - it confused me when I saw it first (though I understand now you mean not-Mock)

Class is very single-monitor specific, please add a "FIXME - won't work with multimonitor" somewhere - I know that the QtEventFeeder has the same issue, but I just want to document it clearly for ourselves when we start thinking about desktop.

+ int mirMotionAction = event.action & MirEventActionMask;
const?

+ // Qt needs a happy, sane stream of touch events. So let's make sure we're not forwarding
+ // any insanity.
Add QTBUG here perhaps?

+ qCWarning(QTMIR_MIR_MESSAGES)
I think a dedicated logging category for this would make sense. QTMIR_INPUT_PROCESSING -> qtmir.mir.input maybe?

+void QtEventFeederTest::setIrrelevantMockWindowSystemExpectations()
+{
+ EXPECT_CALL(*mockWindowSystem, hasTargetWindow())
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(true));
+ EXPECT_CALL(*mockWindowSystem, targetWindowGeometry())
+ .Times(AnyNumber())
+ .WillRepeatedly(Return(QRect(0,0,100,100)));
+}
Nice method name :D They're not exactly irrelevant though. Since you call it before tests run, can't it be run as part of SetUp()?

+ .Times(1);
I don't like it alone on it's own line. Almost looks like a statement of its own.

+ setIrrelevantMockWindowSystemExpectations();
why do you keep calling this? You use .Times(AnyNumber()).WillRepeatedly(Return(true)) so it should not need resetting

+TEST_F(QtEventFeederTest, GenerateMissingTouchEnd)
This test generates a Press event at (10,10). You check press event passed to Qt. Next generate Press event at (20, 20). You ensure this event also generates a Release event for the previous event.
- would help to add this comment to the test. Sorry, but I'm considering somebody other than you or I reading this code!

Otherwise looks good.

Will do functional testing now

review: Needs Fixing (code)

[Gerry Boland (gerboland)]

Desktop tests ok

[Gerry Boland (gerboland)]

I don't see any regression on the phone either.

I still can make apps hang by doing lots of stupid multi-finger gestures. Which confuses me, as I expected your event processing to fix that.

review: Approve

[Daniel d'Andrada (dandrader)]

> I don't see any regression on the phone either.
>
> I still can make apps hang by doing lots of stupid multi-finger gestures.
> Which confuses me, as I expected your event processing to fix that.

That patch ensures that *unity8* receives a clean stream of touch events.
But whether unity8 on its part sends a clean stream of touch events to applications, that's another story

[lp:~dandrader/qtmir/missingTouchEnd-lp1295623]

241. By Daniel d'Andrada on 2014-08-28

QtEventFeeder: s/QtWindowSystem/QtWindowSystemInterface

242. By Daniel d'Andrada on 2014-08-28

Add a TODO notice to that new internal interface

243. By Daniel d'Andrada on 2014-08-28

Declare mirMotionAction a const as it's not meant to be changed

244. By Daniel d'Andrada on 2014-08-28

Using a new logging category

245. By Daniel d'Andrada on 2014-08-28

Comment/explain QtEventFeederTest::GenerateMissingTouchEnd

[Daniel d'Andrada (dandrader)]

> Things I'd like clarified in a big comment in this code:
> 1. this is a workaround for a bug in Qt? If yes, please add the QTBUG number,
> plus a short textual description of that bug. It/when it gets fixed upstream,
> presumably we can remove this?
> 2. is this also processing slightly screwed up events from Mir so that they
> make sense to Qt? Other toolkits may also choke on this, so we should have a
> Mir bug on this topic - and reference it in this code too.
>
>
> Code review:
> +++ src/platforms/mirserver/qteventfeeder.h
> + class QtWindowSystem {
> This is actually a interface, please call it QtWindowSystemInterface -
> hopefully it doesn't clash with Qt's defined one. Else
> QtMirWindowSystemInterface maybe? Is it a Window really? :)

It's impossible to have a clash with anything coming with because it's defined *inside* QtEventFeeder class. So it's inside QtEventFeeder's namespace sort of. It's also prefixed with "Qt", whereas Qt itself uses just "Q" for prefixing its classes.

Changed it to adhere to the "FooInterface" convention.

>
> +++ src/platforms/mirserver/qteventfeeder.cpp
> + class RealQtWindowSystem
> if you do the above rename, then you can remove "Real" from the name - it
> confused me when I saw it first (though I understand now you mean not-Mock)

Done.

>
> Class is very single-monitor specific, please add a "FIXME - won't work with
> multimonitor" somewhere - I know that the QtEventFeeder has the same issue,
> but I just want to document it clearly for ourselves when we start thinking
> about desktop.

Done.

>
> + int mirMotionAction = event.action & MirEventActionMask;
> const?
>

Done.

> + // Qt needs a happy, sane stream of touch events. So let's make sure we're
> not forwarding
> + // any insanity.
> Add QTBUG here perhaps?

hmm... Not necessarily a bug as you cannot really assume that Qt should cope with a messed up platform abstraction. It would be great if it did, but not a necessity.

>
> + qCWarning(QTMIR_MIR_MESSAGES)
> I think a dedicated logging category for this would make sense.
> QTMIR_INPUT_PROCESSING -> qtmir.mir.input maybe?

Done.

>
> +void QtEventFeederTest::setIrrelevantMockWindowSystemExpectations()
> +{
> + EXPECT_CALL(*mockWindowSystem, hasTargetWindow())
> + .Times(AnyNumber())
> + .WillRepeatedly(Return(true));
> + EXPECT_CALL(*mockWindowSystem, targetWindowGeometry())
> + .Times(AnyNumber())
> + .WillRepeatedly(Return(QRect(0,0,100,100)));
> +}
> Nice method name :D They're not exactly irrelevant though. Since you call it
> before tests run, can't it be run as part of SetUp()?

They are irrelevant because the tests don't care about them. They are like uninteresting implementation details needed to get things working, from the tests point of view.

They can't be part of SetUp() because they have to be done more than once during a test. Everytime Mock::VerifyAndClearExpectations(mockWindowSystem) is called, all expectations are cleared/removed, as the method name says. So you have to set those expectations again after it.

>
> + .Times(1);
> I don't like it alone on it's own line. Almost looks like a statement of its
> own.

It's standard google mock coding style but ok, changed...

[Daniel d'Andrada (dandrader)]

> Things I'd like clarified in a big comment in this code:
> 1. this is a workaround for a bug in Qt?

I wouldn't say it's a bug in Qt. It's just that Qt is more sensible to garbage coming from platform abstraction than we would like. So it would be a nice improvement if it would be more resilient/robust.

> If yes, please add the QTBUG number,
> plus a short textual description of that bug. It/when it gets fixed upstream,
> presumably we can remove this?
> 2. is this also processing slightly screwed up events from Mir so that they
> make sense to Qt? Other toolkits may also choke on this, so we should have a
> Mir bug on this topic - and reference it in this code too.

It's not only about protecting against possible garbage coming from Mir, but also about sanity checking what QtEventFeeder itself does before finally sending the generated touch events down to Qt. Previously, for instance, there was a good chance that QtEventFeeder was sending some (possibly inconsistent) touch events in reaction to mir hover events.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:244
http://jenkins.qa.ubuntu.com/job/qtmir-ci/43/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/43
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/43

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:245
http://jenkins.qa.ubuntu.com/job/qtmir-ci/44/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-amd64-ci/44
    SUCCESS: http://jenkins.qa.ubuntu.com/job/qtmir-utopic-armhf-ci/44

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

review: Approve (continuous-integration)

[Gerry Boland (gerboland)]

Perfect, thank you

review: Approve

=== added directory 'src/common'
=== renamed file 'src/modules/Unity/Application/debughelpers.cpp' => 'src/common/debughelpers.cpp'
--- src/modules/Unity/Application/debughelpers.cpp	2014-07-25 15:29:20 +0000
+++ src/common/debughelpers.cpp	2014-08-28 13:13:15 +0000
@@ -17,22 +17,24 @@
 #include "debughelpers.h"
 #include <QTouchEvent>
 
+#include <mir_toolkit/event.h>
+
 // Unity API
 #include <unity/shell/application/ApplicationInfoInterface.h>
 
-QString touchPointStateToString(Qt::TouchPointState state)
+const char *touchPointStateToString(Qt::TouchPointState state)
 {
     switch (state) {
     case Qt::TouchPointPressed:
-        return QString("pressed");
+        return "pressed";
     case Qt::TouchPointMoved:
-        return QString("moved");
+        return "moved";
     case Qt::TouchPointStationary:
-        return QString("stationary");
+        return "stationary";
     case Qt::TouchPointReleased:
-        return QString("released");
+        return "released";
     default:
-        return QString("UNKNOWN!");
+        return "UNKNOWN!";
     }
 }
 
@@ -174,6 +176,36 @@
     }
 }
 
+const char *mirMotionActionToStr(int value)
+{
+    switch (value) {
+    case mir_motion_action_move:
+        return "move";
+    case mir_motion_action_down:
+        return "down";
+    case mir_motion_action_up:
+        return "up";
+    case mir_motion_action_pointer_down:
+        return "pointer_down";
+    case mir_motion_action_cancel:
+        return "cancel";
+    case mir_motion_action_pointer_up:
+        return "pointer_up";
+    case mir_motion_action_outside:
+        return "outside";
+    case mir_motion_action_hover_move:
+        return "hover_move";
+    case mir_motion_action_scroll:
+        return "scroll";
+    case mir_motion_action_hover_enter:
+        return "hover_enter";
+    case mir_motion_action_hover_exit:
+        return "hover_exit";
+    default:
+        return "???";
+    }
+}
+
 using namespace unity::shell::application;
 
 const char *applicationStateToStr(int state)

=== renamed file 'src/modules/Unity/Application/debughelpers.h' => 'src/common/debughelpers.h'
--- src/modules/Unity/Application/debughelpers.h	2014-07-25 15:29:20 +0000
+++ src/common/debughelpers.h	2014-08-28 13:13:15 +0000
@@ -23,7 +23,7 @@
 
 class QTouchEvent;
 
-QString touchPointStateToString(Qt::TouchPointState state);
+const char *touchPointStateToString(Qt::TouchPointState state);
 QString touchEventToString(const QTouchEvent *ev);
 
 QString mirSurfaceAttribAndValueToString(MirSurfaceAttrib attrib, int value);
@@ -31,6 +31,7 @@
 const char *mirSurfaceStateToStr(int value);
 const char *mirSurfaceFocusStateToStr(int value);
 const char *mirSurfaceVisibilityToStr(int value);
+const char *mirMotionActionToStr(int value);
 
 const char *applicationStateToStr(int state);
 

=== modified file 'src/modules/Unity/Application/Application.pro'
--- src/modules/Unity/Application/Application.pro	2014-08-05 09:14:13 +0000
+++ src/modules/Unity/Application/Application.pro	2014-08-28 13:13:15 +0000
@@ -12,7 +12,7 @@
 
 PKGCONFIG += mirserver glib-2.0 process-cpp ubuntu-app-launch-2
 
-INCLUDEPATH += ../../../platforms/mirserver
+INCLUDEPATH += ../../../platforms/mirserver ../../../common
 LIBS += -L../../../platforms/mirserver -lqpa-mirserver
 QMAKE_RPATHDIR += $$[QT_INSTALL_PLUGINS]/platforms # where libqpa-mirserver.so is installed
 
@@ -24,7 +24,7 @@
 
 SOURCES += application_manager.cpp \
     application.cpp \
-    debughelpers.cpp \
+    ../../../common/debughelpers.cpp \
     desktopfilereader.cpp \
     plugin.cpp \
     applicationscreenshotprovider.cpp \
@@ -42,7 +42,7 @@
 HEADERS += application_manager.h \
     applicationcontroller.h \
     application.h \
-    debughelpers.h \
+    ../../../common/debughelpers.h \
     desktopfilereader.h \
     applicationscreenshotprovider.h \
     dbuswindowstack.h \

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-08-22 22:45:47 +0000
+++ src/modules/Unity/Application/application.cpp	2014-08-28 13:13:15 +0000
@@ -17,10 +17,12 @@
 // local
 #include "application.h"
 #include "application_manager.h"
-#include "debughelpers.h"
 #include "desktopfilereader.h"
 #include "taskcontroller.h"
 
+// common
+#include <debughelpers.h>
+
 // QPA mirserver
 #include "logging.h"
 

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2014-08-12 18:23:06 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2014-08-28 13:13:15 +0000
@@ -20,11 +20,13 @@
 
 // local
 #include "application.h"
-#include "debughelpers.h"
 #include "mirbuffersgtexture.h"
 #include "mirsurfaceitem.h"
 #include "logging.h"
 
+// common
+#include <debughelpers.h>
+
 // Qt
 #include <QDebug>
 #include <QQmlEngine>

=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2014-08-08 10:37:50 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2014-08-28 13:13:15 +0000
@@ -19,10 +19,12 @@
 #include <QMutexLocker>
 
 // local
-#include "debughelpers.h"
 #include "mirsurfacemanager.h"
 #include "application_manager.h"
 
+// common
+#include <debughelpers.h>
+
 // QPA mirserver
 #include "nativeinterface.h"
 #include "mirserverconfiguration.h"

=== modified file 'src/platforms/mirserver/logging.h'
--- src/platforms/mirserver/logging.h	2014-07-01 13:38:06 +0000
+++ src/platforms/mirserver/logging.h	2014-08-28 13:13:15 +0000
@@ -21,5 +21,6 @@
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_APPLICATIONS)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_SURFACES)
 Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_MESSAGES)
+Q_DECLARE_LOGGING_CATEGORY(QTMIR_MIR_INPUT)
 
 #endif // UBUNTU_APPLICATION_PLUGIN_LOGGING_H

=== modified file 'src/platforms/mirserver/mirserver.pro'
--- src/platforms/mirserver/mirserver.pro	2014-08-05 09:14:13 +0000
+++ src/platforms/mirserver/mirserver.pro	2014-08-28 13:13:15 +0000
@@ -14,6 +14,8 @@
 QMAKE_CXXFLAGS = -std=c++11 -Werror -Wall
 QMAKE_LFLAGS = -std=c++11 -Wl,-no-undefined
 
+INCLUDEPATH += ../../common
+
 CONFIG   += link_pkgconfig
 PKGCONFIG += mirserver protobuf egl xkbcommon url-dispatcher-1
 
@@ -21,6 +23,7 @@
 
 SOURCES += \
     connectioncreator.cpp \
+    ../../common/debughelpers.cpp \
     focussetter.cpp \
     qteventfeeder.cpp \
     plugin.cpp \
@@ -47,6 +50,7 @@
 
 HEADERS += \
     connectioncreator.h \
+    ../../common/debughelpers.h \
     focussetter.h \
     qteventfeeder.h \
     plugin.h \

=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2014-07-29 15:01:34 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2014-08-28 13:13:15 +0000
@@ -18,10 +18,10 @@
  */
 
 #include "qteventfeeder.h"
+#include "logging.h"
 
 #include <qpa/qplatforminputcontext.h>
 #include <qpa/qplatformintegration.h>
-#include <qpa/qwindowsysteminterface.h>
 #include <QGuiApplication>
 #include <private/qguiapplication_p.h>
 
@@ -30,6 +30,8 @@
 
 #include <QDebug>
 
+Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input")
+
 // from android-input AMOTION_EVENT_ACTION_*, hidden inside mir bowels
 // mir headers should define them
 const int QtEventFeeder::MirEventActionMask = 0xff;
@@ -133,9 +135,61 @@
     return toupper(sym);
 }
 
-
-QtEventFeeder::QtEventFeeder()
+namespace {
+
+class QtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
+
+    bool hasTargetWindow() override
+    {
+        if (mTopLevelWindow.isNull() && !QGuiApplication::topLevelWindows().isEmpty()) {
+            mTopLevelWindow = QGuiApplication::topLevelWindows().first();
+        }
+        return !mTopLevelWindow.isNull();
+    }
+
+    QRect targetWindowGeometry() override
+    {
+        Q_ASSERT(!mTopLevelWindow.isNull());
+        return mTopLevelWindow->geometry();
+    }
+
+    void registerTouchDevice(QTouchDevice *device) override
+    {
+        QWindowSystemInterface::registerTouchDevice(device);
+    }
+
+    void handleExtendedKeyEvent(ulong timestamp, QEvent::Type type, int key,
+                Qt::KeyboardModifiers modifiers,
+                quint32 nativeScanCode, quint32 nativeVirtualKey,
+                quint32 nativeModifiers,
+                const QString& text, bool autorep, ushort count) override
+    {
+        Q_ASSERT(!mTopLevelWindow.isNull());
+        QWindowSystemInterface::handleExtendedKeyEvent(mTopLevelWindow.data(), timestamp, type, key, modifiers,
+                nativeScanCode, nativeVirtualKey, nativeModifiers, text, autorep, count);
+    }
+
+    void handleTouchEvent(ulong timestamp, QTouchDevice *device,
+            const QList<struct QWindowSystemInterface::TouchPoint> &points, Qt::KeyboardModifiers mods) override
+    {
+        Q_ASSERT(!mTopLevelWindow.isNull());
+        QWindowSystemInterface::handleTouchEvent(mTopLevelWindow.data(), timestamp, device, points, mods);
+    }
+private:
+    QPointer<QWindow> mTopLevelWindow;
+};
+
+} // anonymous namespace
+
+
+QtEventFeeder::QtEventFeeder(QtEventFeeder::QtWindowSystemInterface *windowSystem)
 {
+    if (windowSystem) {
+        mQtWindowSystem = windowSystem;
+    } else {
+        mQtWindowSystem = new QtWindowSystem;
+    }
+
     // Initialize touch device. Hardcoded just like in qtubuntu
     // TODO: Create them from info gathered from Mir and store things like device id and source
     //       in a QTouchDevice-derived class created by us. So that we can properly assemble back
@@ -145,7 +199,12 @@
     mTouchDevice->setCapabilities(
             QTouchDevice::Position | QTouchDevice::Area | QTouchDevice::Pressure |
             QTouchDevice::NormalizedPosition);
-    QWindowSystemInterface::registerTouchDevice(mTouchDevice);
+    mQtWindowSystem->registerTouchDevice(mTouchDevice);
+}
+
+QtEventFeeder::~QtEventFeeder()
+{
+    delete mQtWindowSystem;
 }
 
 void QtEventFeeder::dispatch(MirEvent const& event)
@@ -171,11 +230,9 @@
 
 void QtEventFeeder::dispatchKey(MirKeyEvent const& event)
 {
-    if (QGuiApplication::topLevelWindows().isEmpty())
+    if (!mQtWindowSystem->hasTargetWindow())
         return;
 
-    QWindow *window = QGuiApplication::topLevelWindows().first();
-
     ulong timestamp = event.event_time / 1000000;
     xkb_keysym_t xk_sym = static_cast<xkb_keysym_t>(event.key_code);
 
@@ -221,20 +278,33 @@
         }
     }
 
-    QWindowSystemInterface::handleExtendedKeyEvent(window, timestamp, keyType, keyCode, modifiers, event.scan_code, event.key_code, event.modifiers, text);
+    mQtWindowSystem->handleExtendedKeyEvent(timestamp, keyType, keyCode, modifiers,
+            event.scan_code, event.key_code, event.modifiers, text);
 }
 
 void QtEventFeeder::dispatchMotion(MirMotionEvent const& event)
 {
-    if (QGuiApplication::topLevelWindows().isEmpty())
-        return;
-
-    QWindow *window = QGuiApplication::topLevelWindows().first();
+    if (!mQtWindowSystem->hasTargetWindow())
+        return;
+
+    const int mirMotionAction = event.action & MirEventActionMask;
+
+    // Ignore the events that do not interest us (or that we currently don't support or know
+    // how to translate into Qt events)
+    if (mirMotionAction != mir_motion_action_move
+            && mirMotionAction != mir_motion_action_down
+            && mirMotionAction != mir_motion_action_up
+            && mirMotionAction != mir_motion_action_pointer_down
+            && mirMotionAction != mir_motion_action_pointer_up
+            && mirMotionAction != mir_motion_action_cancel) {
+        return;
+    }
+
 
     // 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.
     const float kMaxPressure = 1.28;
-    const QRect kWindowGeometry = window->geometry();
+    const QRect kWindowGeometry = mQtWindowSystem->targetWindowGeometry();
     QList<QWindowSystemInterface::TouchPoint> touchPoints;
 
     // TODO: Is it worth setting the Qt::TouchPointStationary ones? Currently they are left
@@ -257,7 +327,7 @@
         touchPoints.append(touchPoint);
     }
 
-    switch (event.action & MirEventActionMask) {
+    switch (mirMotionAction) {
     case mir_motion_action_move:
         // No extra work needed.
         break;
@@ -291,13 +361,17 @@
     case mir_motion_action_scroll:
     case mir_motion_action_hover_enter:
     case mir_motion_action_hover_exit:
-        default:
-        qWarning() << "unhandled motion event action" << (int)(event.action & MirEventActionMask);
+    default:
+        // Should never reach this point. If so, it's a programming error.
+        qFatal("Trying to handle unsupported motion event action");
     }
 
+    // Qt needs a happy, sane stream of touch events. So let's make sure we're not forwarding
+    // any insanity.
+    validateTouches(touchPoints);
+
     // Touch event propagation.
-    QWindowSystemInterface::handleTouchEvent(
-            window,
+    mQtWindowSystem->handleTouchEvent(
             event.event_time / 1000000, //scales down the nsec_t (int64) to fit a ulong, precision lost but time difference suitable
             mTouchDevice,
             touchPoints);
@@ -323,3 +397,86 @@
     Q_UNUSED(device_id);
     Q_UNUSED(when);
 }
+
+void QtEventFeeder::validateTouches(QList<QWindowSystemInterface::TouchPoint> &touchPoints)
+{
+    QSet<int> updatedTouches;
+
+    {
+        int i = 0;
+        while (i < touchPoints.count()) {
+            bool mustDiscardTouch = !validateTouch(touchPoints[i]);
+            if (mustDiscardTouch) {
+                touchPoints.removeAt(i);
+            } else {
+                updatedTouches.insert(touchPoints.at(i).id);
+                ++i;
+            }
+        }
+    }
+
+    // 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;
+            }
+        }
+    }
+}
+
+bool QtEventFeeder::validateTouch(QWindowSystemInterface::TouchPoint &touchPoint)
+{
+    bool ok = true;
+
+    switch (touchPoint.state) {
+    case Qt::TouchPointPressed:
+        if (mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "Would press an already existing touch (id =" << touchPoint.id
+                << "). Making it move instead.";
+            touchPoint.state = Qt::TouchPointMoved;
+        }
+        mActiveTouches[touchPoint.id] = touchPoint;
+        break;
+    case Qt::TouchPointMoved:
+        if (!mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "Would move a touch that wasn't pressed before (id =" << touchPoint.id
+                << "). Making it press instead.";
+            touchPoint.state = Qt::TouchPointPressed;
+        }
+        mActiveTouches[touchPoint.id] = touchPoint;
+        break;
+    case Qt::TouchPointStationary:
+        if (!mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "There's an stationary touch that wasn't pressed before (id =" << touchPoint.id
+                << "). Making it press instead.";
+            touchPoint.state = Qt::TouchPointPressed;
+        }
+        mActiveTouches[touchPoint.id] = touchPoint;
+        break;
+    case Qt::TouchPointReleased:
+        if (!mActiveTouches.contains(touchPoint.id)) {
+            qCWarning(QTMIR_MIR_INPUT)
+                << "Would release a touch that wasn't pressed before (id =" << touchPoint.id
+                << "). Ignoring it.";
+            ok = false;
+        } else {
+            mActiveTouches.remove(touchPoint.id);
+        }
+        break;
+    default:
+        qFatal("QtEventFeeder: invalid touch state");
+    }
+
+    return ok;
+}

=== modified file 'src/platforms/mirserver/qteventfeeder.h'
--- src/platforms/mirserver/qteventfeeder.h	2014-07-18 20:23:35 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2014-08-28 13:13:15 +0000
@@ -22,6 +22,8 @@
 #include <mir/input/input_dispatcher.h>
 #include <mir/shell/input_targeter.h>
 
+#include <qpa/qwindowsysteminterface.h>
+
 class QTouchDevice;
 
 /*
@@ -30,7 +32,29 @@
 class QtEventFeeder : public mir::input::InputDispatcher
 {
 public:
-    QtEventFeeder();
+    // Interface between QtEventFeeder and the actual QWindowSystemInterface functions
+    // and other related Qt methods and objects to enable replacing them with mocks in
+    // pure unit tests.
+    // TODO - Make it work with multimonitor scenarios
+    class QtWindowSystemInterface {
+        public:
+        virtual ~QtWindowSystemInterface() {}
+        virtual bool hasTargetWindow() = 0;
+        virtual QRect targetWindowGeometry() = 0;
+        virtual void registerTouchDevice(QTouchDevice *device) = 0;
+        virtual void handleExtendedKeyEvent(ulong timestamp, QEvent::Type type, int key,
+                Qt::KeyboardModifiers modifiers,
+                quint32 nativeScanCode, quint32 nativeVirtualKey,
+                quint32 nativeModifiers,
+                const QString& text = QString(), bool autorep = false,
+                ushort count = 1) = 0;
+        virtual void handleTouchEvent(ulong timestamp, QTouchDevice *device,
+                const QList<struct QWindowSystemInterface::TouchPoint> &points,
+                Qt::KeyboardModifiers mods = Qt::NoModifier) = 0;
+    };
+
+    QtEventFeeder(QtWindowSystemInterface *windowSystem = nullptr);
+    virtual ~QtEventFeeder();
 
     static const int MirEventActionMask;
     static const int MirEventActionPointerIndexMask;
@@ -45,8 +69,14 @@
 private:
     void dispatchKey(MirKeyEvent const& event);
     void dispatchMotion(MirMotionEvent const& event);
+    void validateTouches(QList<QWindowSystemInterface::TouchPoint> &touchPoints);
+    bool validateTouch(QWindowSystemInterface::TouchPoint &touchPoint);
 
     QTouchDevice *mTouchDevice;
+    QtWindowSystemInterface *mQtWindowSystem;
+
+    // Maps the id of an active touch to its last known state
+    QHash<int, QWindowSystemInterface::TouchPoint> mActiveTouches;
 };
 
 #endif // MIR_QT_EVENT_FEEDER_H

=== added file 'tests/google-mock.pri'
--- tests/google-mock.pri	1970-01-01 00:00:00 +0000
+++ tests/google-mock.pri	2014-08-28 13:13:15 +0000
@@ -0,0 +1,24 @@
+GMOCK_SOURCES = /usr/src/gmock/src/gmock-all.cc \
+                /usr/src/gmock/src/gmock_main.cc \
+                /usr/src/gtest/src/gtest-all.cc
+
+QMAKE_EXTRA_COMPILERS += gmock_compiler
+gmock_compiler.input = GMOCK_SOURCES
+gmock_compiler.output = $${OUT_PWD}/${QMAKE_FILE_BASE}.o
+gmock_compiler.commands = g++ \
+                          -I/usr/src/gtest \
+                          -I/usr/src/gmock \
+                          -c ${QMAKE_FILE_IN} \
+                          -o ${QMAKE_FILE_OUT}
+gmock_compiler.CONFIG = no_link
+
+QMAKE_EXTRA_COMPILERS += gmock_linker
+gmock_linker.depends = $${OUT_PWD}/gmock-all.o \
+                       $${OUT_PWD}/gmock_main.o \
+                       $${OUT_PWD}/gtest-all.o
+gmock_linker.input = GMOCK_SOURCES
+gmock_linker.output = $${OUT_PWD}/libgmock.a
+gmock_linker.commands = ar -rv ${QMAKE_FILE_OUT} $${OUT_PWD}/gmock-all.o $${OUT_PWD}/gmock_main.o $${OUT_PWD}/gtest-all.o
+gmock_linker.CONFIG = combine explicit_dependencies no_link target_predeps
+
+LIBS += $${OUT_PWD}/libgmock.a

=== added directory 'tests/mirserver'
=== added directory 'tests/mirserver/QtEventFeeder'
=== added file 'tests/mirserver/QtEventFeeder/QtEventFeeder.pro'
--- tests/mirserver/QtEventFeeder/QtEventFeeder.pro	1970-01-01 00:00:00 +0000
+++ tests/mirserver/QtEventFeeder/QtEventFeeder.pro	2014-08-28 13:13:15 +0000
@@ -0,0 +1,16 @@
+include(../../test-includes.pri)
+
+TARGET = QtEventFeederTest
+
+QT += gui-private
+
+INCLUDEPATH += \
+    ../../../src/platforms/mirserver \
+    ../../../src/common
+
+SOURCES += \
+    qteventfeeder_test.cpp \
+    ../../../src/common/debughelpers.cpp
+
+LIBS += -Wl,-rpath,$${OUT_PWD}/../../../src/platforms/mirserver \
+    -L../../../src/platforms/mirserver -lqpa-mirserver

=== added file 'tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h'
--- tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	1970-01-01 00:00:00 +0000
+++ tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2014-08-28 13:13:15 +0000
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2014 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#ifndef MOCK_QTWINDOWSYSTEM_H
+#define MOCK_QTWINDOWSYSTEM_H
+
+#include <qteventfeeder.h>
+
+class MockQtWindowSystem : public QtEventFeeder::QtWindowSystemInterface {
+public:
+    MOCK_METHOD0(hasTargetWindow, bool());
+    MOCK_METHOD0(targetWindowGeometry, QRect());
+    MOCK_METHOD1(registerTouchDevice, void(QTouchDevice* device));
+    MOCK_METHOD10(handleExtendedKeyEvent, void(ulong timestamp, QEvent::Type type, int key,
+            Qt::KeyboardModifiers modifiers,
+            quint32 nativeScanCode, quint32 nativeVirtualKey,
+            quint32 nativeModifiers,
+            const QString& text, bool autorep,
+            ushort count));
+    MOCK_METHOD4(handleTouchEvent, void(ulong timestamp, QTouchDevice *device,
+            const QList<struct QWindowSystemInterface::TouchPoint> &points,
+            Qt::KeyboardModifiers mods));
+};
+
+namespace testing
+{
+
+MATCHER(IsPressed, std::string(negation ? "isn't" : "is") + " pressed")
+{
+    return arg.state == Qt::TouchPointPressed;
+}
+
+MATCHER(IsReleased, std::string(negation ? "isn't" : "is") + " released")
+{
+    return arg.state == Qt::TouchPointReleased;
+}
+
+MATCHER(StateIsMoved, "state " + std::string(negation ? "isn't" : "is") + " 'moved'")
+{
+    return arg.state == Qt::TouchPointMoved;
+}
+
+MATCHER_P(HasId, expectedId, "id " + std::string(negation ? "isn't " : "is ") + PrintToString(expectedId))
+{
+    return arg.id == expectedId;
+}
+
+} // namespace testing
+
+
+#endif // MOCK_QTWINDOWSYSTEM_H

=== added file 'tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp'
--- tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	1970-01-01 00:00:00 +0000
+++ tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2014-08-28 13:13:15 +0000
@@ -0,0 +1,224 @@
+/*
+ * Copyright (C) 2014 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 warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, 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/>.
+ *
+ */
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <qteventfeeder.h>
+#include <debughelpers.h>
+
+#include <QGuiApplication>
+#include <QWindow>
+
+#include "mock_qtwindowsystem.h"
+
+using ::testing::_;
+using ::testing::AllOf;
+using ::testing::AnyNumber;
+using ::testing::Contains;
+using ::testing::AtLeast;
+using ::testing::InSequence;
+using ::testing::Mock;
+using ::testing::SizeIs;
+using ::testing::Return;
+
+// own gmock extensions
+using ::testing::IsPressed;
+using ::testing::IsReleased;
+using ::testing::HasId;
+using ::testing::StateIsMoved;
+
+void PrintTo(const struct QWindowSystemInterface::TouchPoint& touchPoint, ::std::ostream* os) {
+    *os << "TouchPoint("
+        << "id=" << touchPoint.id
+        << "," << touchPointStateToString(touchPoint.state)
+        << ")";
+}
+
+class QtEventFeederTest : public ::testing::Test {
+protected:
+    void SetUp() override;
+    void TearDown() override;
+
+    void setIrrelevantMockWindowSystemExpectations();
+
+    MockQtWindowSystem *mockWindowSystem;
+    QtEventFeeder *qtEventFeeder;
+};
+
+void QtEventFeederTest::SetUp()
+{
+    mockWindowSystem = new MockQtWindowSystem;
+
+    EXPECT_CALL(*mockWindowSystem, registerTouchDevice(_));
+
+    qtEventFeeder = new QtEventFeeder(mockWindowSystem);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+}
+
+void QtEventFeederTest::TearDown()
+{
+    // mockWindowSystem will be deleted by QtEventFeeder
+    delete qtEventFeeder;
+}
+
+void QtEventFeederTest::setIrrelevantMockWindowSystemExpectations()
+{
+    EXPECT_CALL(*mockWindowSystem, hasTargetWindow())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*mockWindowSystem, targetWindowGeometry())
+        .Times(AnyNumber())
+        .WillRepeatedly(Return(QRect(0,0,100,100)));
+}
+
+
+/*
+   Mir sends a MirEvent([touch(id=0,state=pressed)]. QtEventFeeder happily forwards that to Qt.
+
+   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
+   touch(id=1,state=pressed) it got. So that Qt receives a correct touch event stream.
+ */
+TEST_F(QtEventFeederTest, GenerateMissingTouchEnd)
+{
+
+    setIrrelevantMockWindowSystemExpectations();
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                                              Contains(AllOf(HasId(0),
+                                                                             IsPressed()))),_)).Times(1);
+
+    MirEvent mirEvent;
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    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.action = mir_motion_action_down;
+    mirEvent.motion.event_time = 123 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+
+    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;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+}
+
+TEST_F(QtEventFeederTest, PressSameTouchTwice)
+{
+    setIrrelevantMockWindowSystemExpectations();
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                                              Contains(AllOf(HasId(0),
+                                                                             IsPressed()))),_)).Times(1);
+
+    MirEvent mirEvent;
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    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.action = mir_motion_action_down;
+    mirEvent.motion.event_time = 123 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
+
+    setIrrelevantMockWindowSystemExpectations();
+
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,AllOf(SizeIs(1),
+                                                              Contains(AllOf(HasId(0), StateIsMoved()))
+                                                             ),_)).Times(1);
+
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    mirEvent.motion.pointer_coordinates[0].id = 0;
+    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, IgnoreHovering)
+{
+    setIrrelevantMockWindowSystemExpectations();
+    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,_,_)).Times(0);
+
+    MirEvent mirEvent;
+    mirEvent.type = mir_event_type_motion;
+    mirEvent.motion.pointer_count = 1;
+    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.action = mir_motion_action_hover_enter;
+    mirEvent.motion.event_time = 123 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    mirEvent.motion.pointer_coordinates[0].x = 20;
+    mirEvent.motion.pointer_coordinates[0].y = 20;
+    mirEvent.motion.action = mir_motion_action_hover_move;
+    mirEvent.motion.event_time = 125 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+
+    mirEvent.motion.action = mir_motion_action_hover_exit;
+    mirEvent.motion.event_time = 127 * 1000000;
+
+    qtEventFeeder->dispatch(mirEvent);
+}

=== added file 'tests/mirserver/mirserver.pro'
--- tests/mirserver/mirserver.pro	1970-01-01 00:00:00 +0000
+++ tests/mirserver/mirserver.pro	2014-08-28 13:13:15 +0000
@@ -0,0 +1,2 @@
+TEMPLATE = subdirs
+SUBDIRS = QtEventFeeder

=== modified file 'tests/modules/common/common.pri'
--- tests/modules/common/common.pri	2014-08-14 15:38:15 +0000
+++ tests/modules/common/common.pri	2014-08-28 13:13:15 +0000
@@ -1,8 +1,7 @@
-CONFIG += link_pkgconfig no_keywords # keywords clash with ProcessC++
-PKGCONFIG += mirserver process-cpp ubuntu-app-launch-2
+CONFIG += no_keywords # keywords clash with ProcessC++
+PKGCONFIG += process-cpp ubuntu-app-launch-2
 
-QT += quick testlib
-QMAKE_CXXFLAGS = -std=c++11
+QT += quick
 
 HEADERS += ../common/mock_application_controller.h \
     ../common/mock_desktop_file_reader.h \
@@ -19,31 +18,7 @@
 INCLUDEPATH += ../../../src/modules \
     ../common
 
-
-GMOCK_SOURCES = /usr/src/gmock/src/gmock-all.cc \
-                /usr/src/gmock/src/gmock_main.cc \
-                /usr/src/gtest/src/gtest-all.cc
-
-QMAKE_EXTRA_COMPILERS += gmock_compiler
-gmock_compiler.input = GMOCK_SOURCES
-gmock_compiler.output = $${OUT_PWD}/${QMAKE_FILE_BASE}.o
-gmock_compiler.commands = g++ \
-                          -I/usr/src/gtest \
-                          -I/usr/src/gmock \
-                          -c ${QMAKE_FILE_IN} \
-                          -o ${QMAKE_FILE_OUT}
-gmock_compiler.CONFIG = no_link
-
-QMAKE_EXTRA_COMPILERS += gmock_linker
-gmock_linker.depends = $${OUT_PWD}/gmock-all.o \
-                       $${OUT_PWD}/gmock_main.o \
-                       $${OUT_PWD}/gtest-all.o
-gmock_linker.input = GMOCK_SOURCES
-gmock_linker.output = $${OUT_PWD}/libgmock.a
-gmock_linker.commands = ar -rv ${QMAKE_FILE_OUT} $${OUT_PWD}/gmock-all.o $${OUT_PWD}/gmock_main.o $${OUT_PWD}/gtest-all.o
-gmock_linker.CONFIG = combine explicit_dependencies no_link target_predeps
-
-LIBS += $${OUT_PWD}/libgmock.a \
+LIBS += \
     -Wl,-rpath,$${OUT_PWD}/../../../src/modules/Unity/Application \
     -L$${OUT_PWD}/../../../src/modules/Unity/Application -lunityapplicationplugin \
     -Wl,-rpath,$${OUT_PWD}/../../../src/platforms/mirserver \

=== modified file 'tests/test-includes.pri'
--- tests/test-includes.pri	2014-07-07 19:33:56 +0000
+++ tests/test-includes.pri	2014-08-28 13:13:15 +0000
@@ -4,3 +4,12 @@
 # adds a 'make install' that installs the test cases, which we do not want.
 # Can configure it not to do that with 'no_testcase_installs'
 CONFIG += testcase no_testcase_installs
+
+QMAKE_CXXFLAGS = -std=c++11
+
+QT += testlib
+
+CONFIG += link_pkgconfig
+PKGCONFIG += mirserver
+
+include(google-mock.pri)

=== modified file 'tests/tests.pro'
--- tests/tests.pro	2014-07-01 13:38:06 +0000
+++ tests/tests.pro	2014-08-28 13:13:15 +0000
@@ -1,2 +1,2 @@
 TEMPLATE = subdirs
-SUBDIRS = modules
+SUBDIRS = modules mirserver