Merge lp:~elopio/ubuntu-ui-toolkit/device_emulation_scenarios into lp:ubuntu-ui-toolkit

[Leo Arias]

[lp:~elopio/ubuntu-ui-toolkit/device_emulation_scenarios]

950. By Leo Arias on 2014-05-09

Merged with staging.

951. By Leo Arias on 2014-06-25

Merged with trunk.

952. By Leo Arias on 2014-06-25

Fixed the merge.

953. By Leo Arias on 2014-06-26

Added test scenarios for the gallery.

954. By Leo Arias on 2014-06-26

Reverted the size change.

955. By Leo Arias on 2014-06-26

Added a test for the device case.

956. By Leo Arias on 2014-06-26

Made explicit the use of scenarios.

957. By Leo Arias on 2014-06-26

Added python-gi as a dependency.

958. By Leo Arias on 2014-06-26

Fixed skip message.

959. By Leo Arias on 2014-06-27

Merged with staging.

960. By Leo Arias on 2014-07-07

Merged with staging.

961. By Leo Arias on 2014-07-07

Start the gallery tests with the toolbar closed.

962. By Leo Arias on 2014-07-07

Scroll the thumb from its bottom.

963. By Leo Arias on 2014-07-07

Fix pep8.

964. By Leo Arias on 2014-07-07

Close the toolbar only when needed.

965. By Leo Arias on 2014-07-07

Move to the thumb first.

966. By Leo Arias on 2014-07-08

Make sure that all scenarios tests will also run on the phone.

Unmerged revisions

=== modified file 'components.api'
--- components.api	2014-05-28 18:08:33 +0000
+++ components.api	2014-06-25 19:24:49 +0000
@@ -901,3 +901,51 @@
     prototype: "QQuickItem"
     exports: ["TextureFromImage 0.1", "TextureFromImage 1.0"]
     Property { name: "image"; type: "QImage" }
+    name: "UCTestExtras"
+    prototype: "QObject"
+    exports: ["TestExtras 1.0"]
+    Property { name: "touchPresent"; type: "bool"; isReadonly: true }
+    Method { name: "registerTouchDevice" }
+    Method {
+    name: "touchPress"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "point"; type: "QPoint" }
+    Method {
+    name: "touchRelease"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "point"; type: "QPoint" }
+    Method {
+    name: "touchClick"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "point"; type: "QPoint" }
+    Method {
+    name: "touchLongPress"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "point"; type: "QPoint" }
+    Method {
+    name: "touchDoubleClick"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "point"; type: "QPoint" }
+    Method {
+    name: "touchMove"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "point"; type: "QPoint" }
+    Method {
+    name: "touchDrag"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "from"; type: "QPoint" }
+    Parameter { name: "delta"; type: "QPoint" }
+    Parameter { name: "steps"; type: "int" }
+    Method {
+    name: "touchDrag"
+    Parameter { name: "touchId"; type: "int" }
+    Parameter { name: "item"; type: "QQuickItem"; isPointer: true }
+    Parameter { name: "from"; type: "QPoint" }
+    Parameter { name: "delta"; type: "QPoint" }
 
=== modified file 'debian/ubuntu-ui-toolkit-autopilot.install'
--- debian/ubuntu-ui-toolkit-autopilot.install	2014-05-14 11:00:20 +0000
+++ debian/ubuntu-ui-toolkit-autopilot.install	2014-06-25 19:24:49 +0000
@@ -1,3 +1,3 @@
 usr/lib/python3
-usr/lib/ubuntu-ui-toolkit/launcher
+usr/lib/*/ubuntu-ui-toolkit/launcher
 usr/lib/python2.7
 
=== modified file 'documentation/overview.qdoc'
--- documentation/overview.qdoc	2014-04-29 05:39:04 +0000
+++ documentation/overview.qdoc	2014-06-25 19:24:49 +0000
@@ -106,4 +106,11 @@
          import Ubuntu.PerformanceMetrics 1.0
      \endcode
      \annotatedlist ubuntu-performance-metrics
+
+     \part Test extensions
+     Available through:
+     \code
+         import Ubuntu Test 1.0
+     \endcode
+     \annotatedlist ubuntu-test
  */
 
=== modified file 'documentation/ubuntu-ui-toolkit-common.qdocconf'
--- documentation/ubuntu-ui-toolkit-common.qdocconf	2014-04-29 05:39:04 +0000
+++ documentation/ubuntu-ui-toolkit-common.qdocconf	2014-06-25 19:24:49 +0000
@@ -8,6 +8,8 @@
 headerdirs += ../modules/Ubuntu/Layouts/plugin
 sourcedirs += ../modules/Ubuntu/PerformanceMetrics
 headerdirs += ../modules/Ubuntu/PerformanceMetrics/plugin
+sourcedirs += ../modules/Ubuntu/Test
+headerdirs += ../modules/Ubuntu/Test/plugin
 exampledirs += snippets
 excludedirs = ../modules/Ubuntu/Components/Themes
 imagedirs = images
 
=== added file 'examples/ubuntu-ui-toolkit-gallery/Styles.qml'
--- examples/ubuntu-ui-toolkit-gallery/Styles.qml	1970-01-01 00:00:00 +0000
+++ examples/ubuntu-ui-toolkit-gallery/Styles.qml	2014-06-25 19:24:49 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 1.1
+
+Template {
+    objectName: "stylesTemplate"
+
+    Label {
+        anchors.left: parent.left
+        anchors.right: parent.right
+
+        text: i18n.tr("Switch between old and new style header")
+    }
+
+    OptionSelector {
+        model: [ i18n.tr('Header with Toolbar'), i18n.tr('New Style Header') ]
+        expanded: true
+        onSelectedIndexChanged: gallery.useDeprecatedToolbar = (selectedIndex == 0)
+    }
+
+    Label {
+        anchors.left: parent.left
+        anchors.right: parent.right
+
+        text: i18n.tr("Switch between themes")
+    }
+
+    OptionSelector {
+        model: [ 'Ambiance', 'SuruDark' ]
+        expanded: true
+        onSelectedIndexChanged: Theme.name = 'Ubuntu.Components.Themes.%1'.arg(model[selectedIndex])
+    }
+}
 
=== added file 'examples/ubuntu-ui-toolkit-gallery/Toolbar.qml'
--- examples/ubuntu-ui-toolkit-gallery/Toolbar.qml	1970-01-01 00:00:00 +0000
+++ examples/ubuntu-ui-toolkit-gallery/Toolbar.qml	2014-06-25 19:24:49 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+import QtQuick 2.0
+import Ubuntu.Components 0.1
+import Ubuntu.Components.Popups 0.1
+
+Template {
+    objectName: "popoversTemplate"
+
+    tools: ToolbarItems {
+        ToolbarButton {
+            text: "Call"
+            iconName: "call-start"
+        }
+        ToolbarButton {
+            text: i18n.tr("Share")
+            iconName: "share"
+        }
+        ToolbarButton {
+            iconName: "settings"
+        }
+        ToolbarButton {
+            iconName: "speaker"
+        }
+    }
+
+    TemplateSection {
+        className: "Toolbar"
+        documentation: "qml-ubuntu-components-toolbar0-%1.html".arg(className.toLowerCase())
+
+        TemplateRow {
+            title: i18n.tr("See below")
+        }
+    }
+}
 
=== modified file 'examples/ubuntu-ui-toolkit-gallery/WidgetsModel.qml'
--- examples/ubuntu-ui-toolkit-gallery/WidgetsModel.qml	2014-04-30 10:26:35 +0000
+++ examples/ubuntu-ui-toolkit-gallery/WidgetsModel.qml	2014-06-25 19:24:49 +0000
@@ -23,6 +23,11 @@
         label: "Navigation"
         source: "Navigation.qml"
     }
+    ListElement {
+        objectName: "stylesElement"
+        label: "Styles"
+        source: "Styles.qml"
+    }
 
     ListElement {
         objectName: "togglesElement"
@@ -30,6 +35,11 @@
         source: "Toggles.qml"
     }
     ListElement {
+        objectName: "toolbarElement"
+        label: "Toolbar"
+        source: "Toolbar.qml"
+    }
+    ListElement {
         objectName: "buttonsElement"
         label: "Buttons"
         source: "Buttons.qml"
 
=== modified file 'modules/Ubuntu/Components/Icon.qml'
--- modules/Ubuntu/Components/Icon.qml	2014-04-23 08:50:20 +0000
+++ modules/Ubuntu/Components/Icon.qml	2014-06-25 19:24:49 +0000
@@ -103,12 +103,12 @@
         id: colorizedImage
 
         anchors.fill: parent
-        visible: active && image.status == Image.Ready
+        visible: active
 
         // Whether or not a color has been set.
         property bool active: keyColorOut != Qt.rgba(0.0, 0.0, 0.0, 0.0)
 
-        property Image source: visible ? image : null
+        property Image source: active && image.status == Image.Ready ? image : null
         property color keyColorOut: Qt.rgba(0.0, 0.0, 0.0, 0.0)
         property color keyColorIn: "#808080"
         property real threshold: 0.1
 
=== modified file 'modules/Ubuntu/Components/Label.qml'
--- modules/Ubuntu/Components/Label.qml	2014-05-22 09:44:01 +0000
+++ modules/Ubuntu/Components/Label.qml	2014-06-25 19:24:49 +0000
@@ -55,8 +55,6 @@
     property string fontSize: "medium"
 
     font.pixelSize: FontUtils.sizeToPixels(fontSize)
-    font.family: "Ubuntu"
-    font.weight: Font.Light
     color: Theme.palette.selected.backgroundText
 
     /* FIXME: workaround for QTBUG 35095 where Text's alignment is incorrect
 
=== modified file 'modules/Ubuntu/Components/OrientationHelper.qml'
--- modules/Ubuntu/Components/OrientationHelper.qml	2014-06-09 09:07:40 +0000
+++ modules/Ubuntu/Components/OrientationHelper.qml	2014-06-25 19:24:49 +0000
@@ -14,7 +14,7 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-import QtQuick 2.0
+import QtQuick 2.2
 import QtQuick.Window 2.0
 import Ubuntu.Components 1.0
 
@@ -136,6 +136,17 @@
                     target: orientationHelper
                     rotation: 0
                 }
+                StateChangeScript {
+                    name: "anchorsScript"
+                    script: {
+                        orientationHelper.anchors.fill = null;
+                        orientationHelper.anchors.leftMargin = 0;
+                        orientationHelper.anchors.rightMargin = 0;
+                        orientationHelper.anchors.topMargin = 0;
+                        orientationHelper.anchors.bottomMargin = 0;
+                        orientationHelper.anchors.fill = orientationHelper.parent;
+                    }
+                }
             },
             State {
                 name: "180"
@@ -143,17 +154,33 @@
                     target: orientationHelper
                     rotation: 180
                 }
+                StateChangeScript {
+                    name: "anchorsScript"
+                    script: {
+                        orientationHelper.anchors.fill = null;
+                        orientationHelper.anchors.leftMargin = 0;
+                        orientationHelper.anchors.rightMargin = 0;
+                        orientationHelper.anchors.topMargin = 0;
+                        orientationHelper.anchors.bottomMargin = 0;
+                        orientationHelper.anchors.fill = orientationHelper.parent;
+                    }
+                }
             },
             State {
                 name: "270"
                 PropertyChanges {
                     target: orientationHelper
                     rotation: 270
-                    anchors {
-                        leftMargin: (parent.width - parent.height) / 2
-                        rightMargin: anchors.leftMargin
-                        topMargin: -anchors.leftMargin
-                        bottomMargin: anchors.topMargin
+                }
+                StateChangeScript {
+                    name: "anchorsScript"
+                    script: {
+                        orientationHelper.anchors.fill = null;
+                        orientationHelper.anchors.topMargin = Qt.binding(function() {return -(parent.width - parent.height) / 2});
+                        orientationHelper.anchors.bottomMargin = Qt.binding(function() {return -(parent.width - parent.height) / 2});
+                        orientationHelper.anchors.leftMargin = Qt.binding(function() {return (parent.width - parent.height) / 2});
+                        orientationHelper.anchors.rightMargin = Qt.binding(function() {return (parent.width - parent.height) / 2});
+                        orientationHelper.anchors.fill = orientationHelper.parent;
                     }
                 }
             },
@@ -162,11 +189,16 @@
                 PropertyChanges {
                     target: orientationHelper
                     rotation: 90
-                    anchors {
-                        leftMargin: (parent.width - parent.height) / 2
-                        rightMargin: anchors.leftMargin
-                        topMargin: -anchors.leftMargin
-                        bottomMargin: anchors.topMargin
+                }
+                StateChangeScript {
+                    name: "anchorsScript"
+                    script: {
+                        orientationHelper.anchors.fill = null;
+                        orientationHelper.anchors.topMargin = Qt.binding(function() {return -(parent.width - parent.height) / 2});
+                        orientationHelper.anchors.bottomMargin = Qt.binding(function() {return -(parent.width - parent.height) / 2});
+                        orientationHelper.anchors.leftMargin = Qt.binding(function() {return (parent.width - parent.height) / 2});
+                        orientationHelper.anchors.rightMargin = Qt.binding(function() {return (parent.width - parent.height) / 2});
+                        orientationHelper.anchors.fill = orientationHelper.parent;
                     }
                 }
             }
@@ -176,18 +208,20 @@
             Transition {
                 id: orientationTransition
                 ParallelAnimation {
-                    SequentialAnimation {
-                        PauseAnimation {
-                            duration: 25
-                        }
-                        PropertyAction {
-                            target: orientationHelper
-                            properties: "anchors.topMargin,anchors.bottomMargin,anchors.rightMargin,anchors.leftMargin"
-                        }
+                    /* FIXME: this is a workaround for 2 issues that trigger too many changes
+                              to the width and height of orientationHelper which creates intermediary
+                              states of the UI with unexpected sizes:
+                        1) upon state change fast-forwarding is used which means that the final values are computed and applied
+                          then immediately reverted before the actual transition is applied
+                        2) when margins are applied, width and height are updated separately
+
+                        Without these issues, regular PropertyChanges could be used to set the margins.
+                    */
+                    ScriptAction {
+                        scriptName: "anchorsScript"
                     }
-                    RotationAnimation {
+                    RotationAnimator {
                         target: orientationHelper
-                        properties: "rotation"
                         duration: UbuntuAnimation.FastDuration
                         easing: UbuntuAnimation.StandardEasing
                         direction: RotationAnimation.Shortest
 
=== modified file 'modules/Ubuntu/Components/plugin/uctheme.cpp'
--- modules/Ubuntu/Components/plugin/uctheme.cpp	2014-06-09 08:43:30 +0000
+++ modules/Ubuntu/Components/plugin/uctheme.cpp	2014-06-25 19:24:49 +0000
@@ -21,6 +21,7 @@
 #include "listener.h"
 #include "quickutils.h"
 #include "i18n.h"
+#include "ucfontutils.h"
 
 #include <QtQml/qqml.h>
 #include <QtQml/qqmlinfo.h>
@@ -32,6 +33,8 @@
 #include <QtCore/QTextStream>
 #include <QtCore/QLibraryInfo>
 #include <QtCore/QStandardPaths>
+#include <QtGui/QGuiApplication>
+#include <QtGui/QFont>
 
 /*!
     \qmltype Theme
@@ -114,6 +117,13 @@
 
     QObject::connect(this, SIGNAL(nameChanged()),
                      this, SLOT(loadPalette()), Qt::UniqueConnection);
+
+    // set the default font
+    QFont defaultFont;
+    defaultFont.setFamily("Ubuntu");
+    defaultFont.setPixelSize(UCFontUtils::instance().sizeToPixels("medium"));
+    defaultFont.setWeight(QFont::Light);
+    QGuiApplication::setFont(defaultFont);
 }
 
 void UCTheme::updateEnginePaths()
 
=== modified file 'modules/Ubuntu/Test/UbuntuTestCase.qml'
--- modules/Ubuntu/Test/UbuntuTestCase.qml	2014-05-02 07:22:52 +0000
+++ modules/Ubuntu/Test/UbuntuTestCase.qml	2014-06-25 19:24:49 +0000
@@ -19,9 +19,9 @@
 import Ubuntu.Components 1.1
 
 /*!
-    \qmlabstract UbuntuTestCase
-    \inqmlmodule Ubuntu.Test 0.1
-    \ingroup ubuntu
+    \qmltype UbuntuTestCase
+    \inqmlmodule Ubuntu.Test 1.0
+    \ingroup ubuntu-test
     \brief The UbuntuTestCase class expands the default TestCase class.
 
     \b{This component is under heavy development.}
@@ -51,6 +51,9 @@
 		return null;
 	}
 
+    /*!
+      Find a non-visual child such as QtObject based on objectName.
+      */
 	function findInvisibleChild(obj,objectName) {
 		var childs = new Array(0);
 		childs.push(obj)
@@ -113,7 +116,7 @@
       \qmlmethod UbuntuTestCase::flick(item, x, y, dx, dy, pressTimeout = -1, steps = -1, button = Qt.LeftButton, modifiers = Qt.NoModifiers, delay = -1)
 
       The function produces a flick event when executed on Flickables. When used
-      on other components it provides the same functionality as \l mouseDrag()
+      on other components it provides the same functionality as \c mouseDrag()
       function. The optional \a pressTimeout parameter can be used to introduce
       a small delay between the mouse press and the first mouse move. Setting a
       negative or zero value will disable the timeout.
@@ -169,8 +172,6 @@
         system of \a item into window co-ordinates and then delivered.
         If \a item is obscured by another item, or a child of \a item occupies
         that position, then the event will be delivered to the other item instead.
-
-        \sa mouseRelease(), mouseClick(), mouseDoubleClick(), mouseMove(), mouseDrag(), mouseWheel()
       */
     function mouseLongPress(item, x, y, button, modifiers, delay) {
         mousePress(item, x, y, button, modifiers, delay);
 
=== modified file 'modules/Ubuntu/Test/plugin/plugin.pro'
--- modules/Ubuntu/Test/plugin/plugin.pro	2014-06-10 09:28:21 +0000
+++ modules/Ubuntu/Test/plugin/plugin.pro	2014-06-25 19:24:49 +0000
@@ -1,6 +1,6 @@
 TEMPLATE = lib
 TARGET = ../UbuntuTest
-QT += core-private qml qml-private quick quick-private gui-private
+QT += core-private qml qml-private quick quick-private gui-private testlib
 
 equals(QT_MAJOR_VERSION, 5):lessThan(QT_MINOR_VERSION, 2) {
     QT += v8-private
@@ -15,9 +15,13 @@
 
 HEADERS += \
     uctestcase.h \
+    testplugin.h \
+    uctestextras.h
 
 SOURCES += \
     uctestcase.cpp \
+    testplugin.cpp \
+    uctestextras.cpp
 
 # deployment rules for the plugin
 installPath = $$[QT_INSTALL_QML]/$$replace(uri, \\., /)
 
=== added file 'modules/Ubuntu/Test/plugin/testplugin.cpp'
--- modules/Ubuntu/Test/plugin/testplugin.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Test/plugin/testplugin.cpp	2014-06-25 19:24:49 +0000
@@ -0,0 +1,32 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "testplugin.h"
+#include <QtQml>
+#include "uctestextras.h"
+
+static QObject *registerExtras(QQmlEngine *engine, QJSEngine *scriptEngine)
+{
+    Q_UNUSED(engine)
+    Q_UNUSED(scriptEngine)
+
+    return new UCTestExtras;
+}
+
+void TestPlugin::registerTypes(const char *uri)
+{
+    qmlRegisterSingletonType<UCTestExtras>(uri, 1, 0, "TestExtras", registerExtras);
+}
 
=== added file 'modules/Ubuntu/Test/plugin/testplugin.h'
--- modules/Ubuntu/Test/plugin/testplugin.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Test/plugin/testplugin.h	2014-06-25 19:24:49 +0000
@@ -0,0 +1,31 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TESTPLUGIN_H
+#define TESTPLUGIN_H
+
+#include <QQmlExtensionPlugin>
+
+class TestPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri);
+};
+
+#endif // TESTPLUGIN_H
 
=== modified file 'modules/Ubuntu/Test/plugin/uctestcase.cpp'
--- modules/Ubuntu/Test/plugin/uctestcase.cpp	2014-06-10 11:45:11 +0000
+++ modules/Ubuntu/Test/plugin/uctestcase.cpp	2014-06-25 19:24:49 +0000
@@ -26,11 +26,8 @@
 #include <QtTest/QtTest>
 #include <QtQuick/QQuickItem>
 
-#include <qpa/qwindowsysteminterface.h>
-
 Q_DECLARE_METATYPE(QList<QQmlError>)
 
-QTouchDevice *UbuntuTestCase::m_touchDevice = 0;
 /*!
  * \ingroup ubuntu
  * \brief UbuntuTestCase is the C++ pendant to the QML UbuntuTestCase.
@@ -63,26 +60,3 @@
 	return m_spy->count();
 }
 
-/*!
- * Registers a touch device if there's none registered.
- */
-void UbuntuTestCase::registerTouchDevice()
-{
-    // check if there is any touch device registered in the system
-    if (!m_touchDevice) {
-        QList<const QTouchDevice*> touchDevices = QTouchDevice::devices();
-        Q_FOREACH(const QTouchDevice *device, touchDevices) {
-            if (device->type() == QTouchDevice::TouchScreen) {
-                m_touchDevice = const_cast<QTouchDevice*>(device);
-                break;
-            }
-        }
-    }
-    // if none, register one
-    if (!m_touchDevice) {
-        m_touchDevice = new QTouchDevice;
-        m_touchDevice->setType(QTouchDevice::TouchScreen);
-        QWindowSystemInterface::registerTouchDevice(m_touchDevice);
-    }
-}
-
 
=== modified file 'modules/Ubuntu/Test/plugin/uctestcase.h'
--- modules/Ubuntu/Test/plugin/uctestcase.h	2014-06-10 11:45:11 +0000
+++ modules/Ubuntu/Test/plugin/uctestcase.h	2014-06-25 19:24:49 +0000
@@ -24,8 +24,6 @@
 #include <QtQuick/QQuickView>
 #include <QtTest/QSignalSpy>
 
-#define CHECK_TOUCH_DEVICE()    if (!checkTouchDevice(__FUNCTION__)) return
-
 class UbuntuTestCase : public QQuickView
 {
     Q_OBJECT
@@ -44,73 +42,8 @@
         qFatal("No item '%s' found", qPrintable(objectName));
     }
 
-    static void registerTouchDevice();
-
-    inline static void touchPress(int touchId, QWindow *window, const QPoint &point)
-    {
-        CHECK_TOUCH_DEVICE();
-        QTest::touchEvent(window, m_touchDevice).press(touchId, point, window);
-    }
-    inline static void touchRelease(int touchId, QWindow *window, const QPoint &point)
-    {
-        CHECK_TOUCH_DEVICE();
-        QTest::touchEvent(window, m_touchDevice).release(touchId, point, window);
-    }
-    inline static void touchClick(int touchId, QWindow *window, const QPoint &point)
-    {
-        CHECK_TOUCH_DEVICE();
-        touchPress(touchId, window, point);
-        QTest::qWait(10);
-        touchRelease(touchId, window, point);
-    }
-    inline static void touchLongPress(int touchId, QWindow *window, const QPoint &point)
-    {
-        CHECK_TOUCH_DEVICE();
-        touchPress(touchId, window, point);
-        QTest::qWait(800);
-    }
-    inline static void touchDoubleClick(int touchId, QWindow *window, const QPoint &point)
-    {
-        CHECK_TOUCH_DEVICE();
-        touchClick(touchId, window, point);
-        QTest::qWait(10);
-        touchClick(touchId, window, point);
-    }
-    inline static void touchMove(int touchId, QWindow *window, const QPoint &point)
-    {
-        CHECK_TOUCH_DEVICE();
-        QTest::touchEvent(window, m_touchDevice).move(touchId, point, window);
-    }
-    inline static void touchDrag(int touchId, QWindow *window, const QPoint &from, const QPoint &delta, int steps = 5)
-    {
-        touchPress(touchId, window, from);
-        QTest::qWait(10);
-        QTest::touchEvent(window, m_touchDevice).move(touchId, from, window);
-        qreal stepDx = delta.x() / steps;
-        qreal stepDy = delta.y() / steps;
-        if (!delta.isNull()) {
-            for (int i = 0; i < steps; i++) {
-                QTest::qWait(10);
-                QTest::touchEvent(window, m_touchDevice).move(touchId, from + QPoint(i * stepDx, i * stepDy), window);
-            }
-        }
-        QTest::qWait(10);
-        touchRelease(touchId, window, from + QPoint(stepDx, stepDy));
-    }
-
-
 private:
     QSignalSpy* m_spy;
-    static QTouchDevice *m_touchDevice;
-
-    static inline bool checkTouchDevice(const char *func)
-    {
-        if (!m_touchDevice) {
-            qWarning() << QString("No touch device registered. Register one using registerTouchDevice() before using %1").arg(func);
-            return false;
-        }
-        return true;
-    }
 };
 
 #endif // UBUNTU_TEST_UBUNTUTESTCASE_H
 
=== added file 'modules/Ubuntu/Test/plugin/uctestextras.cpp'
--- modules/Ubuntu/Test/plugin/uctestextras.cpp	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Test/plugin/uctestextras.cpp	2014-06-25 19:24:49 +0000
@@ -0,0 +1,203 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "uctestextras.h"
+#include "uctestcase.h"
+
+#include <qpa/qwindowsysteminterface.h>
+
+const char *DEVICE_MISSING_MSG = "No touch device registered. Register one using registerTouchDevice() before using %1";
+
+#define CHECK_TOUCH_DEVICE(touchId, item) \
+    if (!touchDevicePresent()) { \
+        qWarning() << QString(DEVICE_MISSING_MSG).arg(__FUNCTION__); \
+        return; \
+    } \
+    if (touchId < 0) { \
+        qWarning() << "Invalid touchId specified."; \
+        return; \
+    } \
+    if (!item) { \
+        qWarning() << "Invalid item specified."; \
+        return; \
+    }
+
+QTouchDevice *UCTestExtras::m_touchDevice = 0;
+
+/*!
+ * \qmltype TestExtras
+ * \instantiates UCTestExtras
+ * \inqmlmodule Ubuntu.Test 1.0
+ * \ingroup ubuntu-test
+ * \brief Singleton type providing additional test functions.
+ *
+ * The component provides additional test functions like touch handling, registering
+ * touch device on non-touch screen enabled environment.
+ */
+
+UCTestExtras::UCTestExtras(QObject *parent) :
+    QObject(parent)
+{
+}
+
+/*!
+ * \qmlmethod TestExtras::touchDevicePresent()
+ * Returns true if the system has a touch device registered.
+ */
+bool UCTestExtras::touchDevicePresent()
+{
+    QList<const QTouchDevice*> touchDevices = QTouchDevice::devices();
+    Q_FOREACH(const QTouchDevice *device, touchDevices) {
+        if (device->type() == QTouchDevice::TouchScreen) {
+            return true;
+        }
+    }
+    return false;
+}
+
+/*!
+ * \qmlmethod TestExtras::registerTouchDevice()
+ * Registers a touch device if there's none registered. Calling the function in
+ * touch enabled environment has no effect. The function must be called in initTestCase()
+ * in order to perform touch related tests.
+ */
+void UCTestExtras::registerTouchDevice()
+{
+    // check if there is any touch device registered in the system
+    if (!m_touchDevice) {
+        QList<const QTouchDevice*> touchDevices = QTouchDevice::devices();
+        Q_FOREACH(const QTouchDevice *device, touchDevices) {
+            if (device->type() == QTouchDevice::TouchScreen) {
+                m_touchDevice = const_cast<QTouchDevice*>(device);
+                break;
+            }
+        }
+    }
+    // if none, register one
+    if (!m_touchDevice) {
+        m_touchDevice = new QTouchDevice;
+        m_touchDevice->setType(QTouchDevice::TouchScreen);
+        QWindowSystemInterface::registerTouchDevice(m_touchDevice);
+    }
+}
+
+/*!
+ * \qmlmethod TestExtras::touchPress(touchId, item, point)
+ * The function triggers a touch press event for a given \a touchId on a specific
+ * \a item. The \a point contains the (x,y) coordinates of the event in \a item
+ * coordinates.
+ */
+void UCTestExtras::touchPress(int touchId, QQuickItem *item, const QPoint &point)
+{
+    CHECK_TOUCH_DEVICE(touchId, item);
+    QTest::touchEvent(item->window(), m_touchDevice).press(touchId, item->mapToScene(point).toPoint(), item->window());
+}
+/*!
+ * \qmlmethod TestExtras::touchRelease(touchId, item, point)
+ * The function produces a touch release event on a given \a touchId performed on
+ * \a item at a \a point.
+ */
+void UCTestExtras::touchRelease(int touchId, QQuickItem *item, const QPoint &point)
+{
+    CHECK_TOUCH_DEVICE(touchId, item);
+    QTest::touchEvent(item->window(), m_touchDevice).release(touchId, item->mapToScene(point).toPoint(), item->window());
+}
+/*!
+ * \qmlmethod TestExtras::touchClick(touchId, item, point)
+ * The function performs a pair of \l touchPress and \l touchRelease calls on the same
+ * point resulting in a click like event.
+ */
+void UCTestExtras::touchClick(int touchId, QQuickItem *item, const QPoint &point)
+{
+    CHECK_TOUCH_DEVICE(touchId, item);
+    touchPress(touchId, item, point);
+    QTest::qWait(100);
+    touchRelease(touchId, item, point);
+}
+/*!
+ * \qmlmethod TestExtras::touchLongPress(touchId, item, point)
+ * The function produces a \l touchPress event with a timeout equivalent to the
+ * mouse \c pressAndHold timeout, after which the function returns.
+ */
+void UCTestExtras::touchLongPress(int touchId, QQuickItem *item, const QPoint &point)
+{
+    CHECK_TOUCH_DEVICE(touchId, item);
+    touchPress(touchId, item, point);
+    // 800 miliseconds + 200 to let events processed
+    QTest::qWait(1000);
+}
+/*!
+ * \qmlmethod TestExtras::touchDoubleClick(touchId, item, point)
+ * The function performs two consecutive \l touchClick events with a slight delay
+ * in between each click event.
+ */
+void UCTestExtras::touchDoubleClick(int touchId, QQuickItem *item, const QPoint &point)
+{
+    CHECK_TOUCH_DEVICE(touchId, item);
+    touchClick(touchId, item, point);
+    QTest::qWait(100);
+    touchClick(touchId, item, point);
+}
+/*!
+ * \qmlmethod TestExtras::touchMove(touchId, item, point)
+ * The function moves the touch point identified by the \a touchId to the destination
+ * \a point. The point is in \a item coordinates. The touch point identified by the
+ * \a touchId must be pressed before calling this function in order to produce the
+ * desired functionality. The event can be captured in a \c MultiPointTouchArea through
+ * \c updated() signal.
+ */
+void UCTestExtras::touchMove(int touchId, QQuickItem *item, const QPoint &point)
+{
+    CHECK_TOUCH_DEVICE(touchId, item);
+    QTest::touchEvent(item->window(), m_touchDevice).move(touchId, item->mapToScene(point).toPoint(), item->window());
+}
+/*!
+ * \qmlmethod TestExtras::touchDrag(touchId, item, from, delta, steps = 5)
+ * The function performs a drag gesture on a touch point identified by \a touchId
+ * over an \a item from the starting point \a from with a \a delta. The gesture
+ * is realized with a touch press, \a step moves and a release event.
+ *
+ * By default the function uses 5 steps to produce the gesture. This value can be any
+ * positive number, driving the gesture appliance to be faster (less than 5 moves) or
+ * slower (more than 5 moves). If a negative or 0 value is given, the function will
+ * use the default 5 steps to produce the gesture.
+ */
+void UCTestExtras::touchDrag(int touchId, QQuickItem *item, const QPoint &from, const QPoint &delta, int steps)
+{
+    CHECK_TOUCH_DEVICE(touchId, item);
+    if (delta.isNull()) {
+        qWarning() << "delta point is invalid";
+        return;
+    }
+    if (steps <= 0) {
+        steps = 5;
+    }
+    touchPress(touchId, item, from);
+    QTest::qWait(10);
+    touchMove(touchId, item, from);
+    QPoint movePoint(from);
+    qreal stepDx = delta.x() / steps;
+    qreal stepDy = delta.y() / steps;
+    if (!delta.isNull()) {
+        for (int i = 0; i < steps - 1; i++) {
+            QTest::qWait(10);
+            movePoint += QPoint(stepDx, stepDy);
+            touchMove(touchId, item, movePoint);
+        }
+    }
+    QTest::qWait(10);
+    touchRelease(touchId, item, from + delta);
+}
 
=== added file 'modules/Ubuntu/Test/plugin/uctestextras.h'
--- modules/Ubuntu/Test/plugin/uctestextras.h	1970-01-01 00:00:00 +0000
+++ modules/Ubuntu/Test/plugin/uctestextras.h	2014-06-25 19:24:49 +0000
@@ -0,0 +1,46 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef TESTEXTRAS_H
+#define TESTEXTRAS_H
+
+#include <QtCore/QObject>
+
+class QQuickItem;
+class QTouchDevice;
+class UCTestExtras : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(bool touchPresent READ touchDevicePresent)
+public:
+    explicit UCTestExtras(QObject *parent = 0);
+
+    static bool touchDevicePresent();
+public Q_SLOTS:
+    static void registerTouchDevice();
+    static void touchPress(int touchId, QQuickItem *item, const QPoint &point);
+    static void touchRelease(int touchId, QQuickItem *item, const QPoint &point);
+    static void touchClick(int touchId, QQuickItem *item, const QPoint &point);
+    static void touchLongPress(int touchId, QQuickItem *item, const QPoint &point);
+    static void touchDoubleClick(int touchId, QQuickItem *item, const QPoint &point);
+    static void touchMove(int touchId, QQuickItem *item, const QPoint &point);
+    static void touchDrag(int touchId, QQuickItem *item, const QPoint &from, const QPoint &delta, int steps = 5);
+
+private:
+    static QTouchDevice *m_touchDevice;
+};
+
+#endif // TESTEXTRAS_H
 
=== modified file 'modules/Ubuntu/Test/qmldir'
--- modules/Ubuntu/Test/qmldir	2014-04-20 19:25:12 +0000
+++ modules/Ubuntu/Test/qmldir	2014-06-25 19:24:49 +0000
@@ -1,4 +1,5 @@
 module Ubuntu.Test
+plugin UbuntuTest
 UbuntuTestCase 0.1 UbuntuTestCase.qml
 
 #version 1.0
 
=== modified file 'tests/autopilot/ubuntuuitoolkit/fixture_setup.py'
--- tests/autopilot/ubuntuuitoolkit/fixture_setup.py	2014-05-26 06:40:24 +0000
+++ tests/autopilot/ubuntuuitoolkit/fixture_setup.py	2014-06-25 19:24:49 +0000
@@ -20,6 +20,7 @@
 import tempfile
 
 import fixtures
+from autopilot import display
 
 from ubuntuuitoolkit import base, environment
 
@@ -29,7 +30,7 @@
 import Ubuntu.Components 1.1
 
 MainView {
-    width: units.gu(48)
+    width: units.gu(80)
     height: units.gu(60)
 
     Label {
@@ -105,7 +106,6 @@
         super(InitctlEnvironmentVariable, self).__init__()
         self.variables = kwargs
 
-    def setUp(self):
         super(InitctlEnvironmentVariable, self).setUp()
         for variable, value in self.variables.items():
             self._add_variable_cleanup(variable)
@@ -163,3 +163,37 @@
             shutil.copyfile(
                 xauthority_file_path,
                 os.path.join(directory, '.Xauthority'))
+
+
+class SimulateDevice(fixtures.Fixture):
+
+    def __init__(self, app_width, app_height, grid_unit_px):
+        super(SimulateDevice, self).__init__()
+        self.app_width = app_width
+        self.app_height = app_height
+        self.grid_unit_px = grid_unit_px
+
+    def setUp(self):
+        super(SimulateDevice, self).setUp()
+        if self._is_geometry_larger_than_display(
+                self.app_width, self.app_height):
+            scale_divisor = self._get_scale_divisor()
+            grid_unit_px = self.grid_unit_px // scale_divisor
+            grid_unit_px = self.grid_unit_px
+        self.useFixture(
+            fixtures.EnvironmentVariable(
+                'GRID_UNIT_PX', str(grid_unit_px)))
+
+    def _is_geometry_larger_than_display(self, width, height):
+        screen = display.Display.create()
+        screen_width = screen.get_screen_width()
+        screen_height = screen.get_screen_height()
+        return (width > screen_width) or (height > screen_height)
+
+    def _get_scale_divisor(self):
+        scale_divisor = 2
+        while self._is_geometry_larger_than_display(
+                self.app_width // scale_divisor,
+                self.app_height // scale_divisor):
+            scale_divisor = scale_divisor * 2
+        return scale_divisor
 
=== added file 'tests/autopilot/ubuntuuitoolkit/scenarios.py'
--- tests/autopilot/ubuntuuitoolkit/scenarios.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntuuitoolkit/scenarios.py	2014-06-25 19:24:49 +0000
@@ -0,0 +1,45 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# 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 as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+NEXUS4_DEVICE = 'Nexus4'
+NEXUS10_DEVICE = 'Nexus10'
+DEFAULT_DEVICES = (NEXUS4_DEVICE, NEXUS10_DEVICE)
+
+
+def get_device_simulation_scenarios(devices=DEFAULT_DEVICES):
+    """Return a list of devices to be simulated on tests.
+
+    :param devices: The device or devices to simulate. Default value is all the
+        officially supported devices.
+    :type devices: string or sequence of strings.
+    :return: A list of scenarios to be used with the testscenarios python
+        module, with the values of app_width, app_height and grid_unit
+        corresponding to the selected device.
+
+    """
+    scenarios = []
+    if NEXUS4_DEVICE in devices:
+        scenarios.append(
+            ('Simulating Nexus 4 in desktop',
+             dict(app_width=768, app_height=1280, grid_unit_px=18))
+        )
+    if NEXUS10_DEVICE in devices:
+        scenarios.append(
+            ('Simulating Nexus 10 in desktop',
+             dict(app_width=2560, app_height=1600, grid_unit_px=20))
+        )
+    return scenarios
 
=== modified file 'tests/autopilot/ubuntuuitoolkit/tests/custom_proxy_objects/test_flickable.py'
--- tests/autopilot/ubuntuuitoolkit/tests/custom_proxy_objects/test_flickable.py	2014-05-30 08:21:45 +0000
+++ tests/autopilot/ubuntuuitoolkit/tests/custom_proxy_objects/test_flickable.py	2014-06-25 19:24:49 +0000
@@ -15,6 +15,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 import os
+import subprocess
 
 import testtools
 import ubuntuuitoolkit
@@ -206,8 +207,11 @@
         if os.path.exists(path_to_local_launcher):
             return path_to_local_launcher
         else:
+            arch = subprocess.check_output(
+                ["dpkg-architecture", "-qDEB_HOST_MULTIARCH"],
+                universal_newlines=True).strip()
             path_to_installed_launcher = os.path.join(
-                '/', 'usr', 'lib', 'ubuntu-ui-toolkit', 'launcher')
+                '/', 'usr', 'lib', arch, 'ubuntu-ui-toolkit', 'launcher')
         return path_to_installed_launcher
 
     def test_get_unity_top_container(self):
 
=== modified file 'tests/autopilot/ubuntuuitoolkit/tests/test_fixture_setup.py'
--- tests/autopilot/ubuntuuitoolkit/tests/test_fixture_setup.py	2014-06-03 20:10:53 +0000
+++ tests/autopilot/ubuntuuitoolkit/tests/test_fixture_setup.py	2014-06-25 19:24:49 +0000
@@ -27,7 +27,7 @@
 from autopilot import testcase as autopilot_testcase
 from testtools.matchers import Contains, FileExists, Not
 
-from ubuntuuitoolkit import base, environment, fixture_setup
+from ubuntuuitoolkit import base, environment, fixture_setup, scenarios
 
 
 class FakeApplicationTestCase(testtools.TestCase):
@@ -304,3 +304,25 @@
         self.assertTrue(
             os.path.exists(
                 os.path.join(os.environ.get('HOME'), '.Xauthority')))
+
+
+class SimulateDeviceTestCase(autopilot_testcase.AutopilotTestCase):
+
+    scenarios = scenarios.get_device_simulation_scenarios()
+
+    def test(self):
+        self.useFixture(fixture_setup.SimulateDevice(
+            self.app_width, self.app_height, self.grid_unit_px))
+
+        fake_application = fixture_setup.FakeApplication()
+        self.useFixture(fake_application)
+
+        self.application = self.launch_test_application(
+            base.get_qmlscene_launch_command(),
+            fake_application.qml_file_path,
+            '--desktop_file_hint={0}'.format(
+                fake_application.desktop_file_path),
+            app_type='qt')
+
+        # We can select a component from the application.
+        self.application.select_single('Label', objectName='testLabel')
 
=== added file 'tests/autopilot/ubuntuuitoolkit/tests/test_scenarios.py'
--- tests/autopilot/ubuntuuitoolkit/tests/test_scenarios.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/ubuntuuitoolkit/tests/test_scenarios.py	2014-06-25 19:24:49 +0000
@@ -0,0 +1,50 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+#
+# 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 as published by
+# the Free Software Foundation; version 3.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+import testtools
+
+from ubuntuuitoolkit import scenarios
+
+
+class ScenariosTestCase(testtools.TestCase):
+
+    def test_get_nexus_4_scenario(self):
+        expected_scenarios = [
+            ('Simulating Nexus 4 in desktop',
+             dict(app_width=768, app_height=1280, grid_unit_px=18)),
+        ]
+        test_scenarios = scenarios.get_device_simulation_scenarios(
+            devices=scenarios.NEXUS4_DEVICE)
+        self.assertEqual(expected_scenarios, test_scenarios)
+
+    def test_get_nexus_10_scenario(self):
+        expected_scenarios = [
+            ('Simulating Nexus 10 in desktop',
+             dict(app_width=2560, app_height=1600, grid_unit_px=20))
+        ]
+        test_scenarios = scenarios.get_device_simulation_scenarios(
+            devices=scenarios.NEXUS10_DEVICE)
+        self.assertEqual(expected_scenarios, test_scenarios)
+
+    def test_get_default_scenarios_must_return_supported_devices(self):
+        expected_scenarios = [
+            ('Simulating Nexus 4 in desktop',
+             dict(app_width=768, app_height=1280, grid_unit_px=18)),
+            ('Simulating Nexus 10 in desktop',
+             dict(app_width=2560, app_height=1600, grid_unit_px=20))
+        ]
+        test_scenarios = scenarios.get_device_simulation_scenarios()
+        self.assertEqual(expected_scenarios, test_scenarios)
 
=== added file 'tests/launcher/MouseTouchAdaptor.cpp'
--- tests/launcher/MouseTouchAdaptor.cpp	1970-01-01 00:00:00 +0000
+++ tests/launcher/MouseTouchAdaptor.cpp	2014-06-25 19:24:49 +0000
@@ -0,0 +1,159 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#include "MouseTouchAdaptor.h"
+
+#include <qpa/qwindowsysteminterface.h>
+
+#include <QtGui/QMouseEvent>
+#include <QtTest/QTest>
+
+using QTest::QTouchEventSequence;
+
+namespace {
+Qt::MouseButton translateMouseButton(xcb_button_t detail)
+{
+    switch (detail) {
+        case 1: return Qt::LeftButton;
+        case 2: return Qt::MidButton;
+        case 3: return Qt::RightButton;
+        // Button values 4-7 are Wheel events
+        default: return Qt::NoButton;
+    }
+}
+} // end of anonymous namespace
+
+MouseTouchAdaptor::MouseTouchAdaptor()
+    : m_leftButtonIsPressed(false)
+{
+    m_touchDevice = new QTouchDevice;
+    m_touchDevice->setType(QTouchDevice::TouchScreen);
+    QWindowSystemInterface::registerTouchDevice(m_touchDevice);
+}
+
+bool MouseTouchAdaptor::nativeEventFilter(const QByteArray & eventType,
+                                          void * message, long * /*result*/)
+{
+    if (eventType != "xcb_generic_event_t") {
+        // wrong backend.
+        qWarning("MouseTouchAdaptor: XCB backend not in use. Adaptor inoperative!");
+        return false;
+    }
+
+    xcb_generic_event_t *xcbEvent = static_cast<xcb_generic_event_t *>(message);
+
+    switch (xcbEvent->response_type & ~0x80) {
+        case XCB_BUTTON_PRESS:
+            return handleButtonPress(reinterpret_cast<xcb_button_press_event_t *>(xcbEvent));
+            break;
+        case XCB_BUTTON_RELEASE:
+            return handleButtonRelease(reinterpret_cast<xcb_button_release_event_t *>(xcbEvent));
+            break;
+        case XCB_MOTION_NOTIFY:
+            return handleMotionNotify(reinterpret_cast<xcb_motion_notify_event_t *>(xcbEvent));
+            break;
+        default:
+            return false;
+            break;
+    };
+}
+
+bool MouseTouchAdaptor::handleButtonPress(xcb_button_press_event_t *pressEvent)
+{
+    Qt::MouseButton button = translateMouseButton(pressEvent->detail);
+
+    // Skip the event if it wasn't a left mouse press
+    if (button != Qt::LeftButton) {
+        return false;
+    }
+
+    QPoint windowPos(pressEvent->event_x, pressEvent->event_y);
+
+    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(pressEvent->event));
+
+    // no autoCommit
+    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice, false);
+    touchEvent.press(0, windowPos);
+    // do not process events when committed, let the events be processed with next event loop
+    touchEvent.commit(false);
+
+    m_leftButtonIsPressed = true;
+    return true;
+}
+
+bool MouseTouchAdaptor::handleButtonRelease(xcb_button_release_event_t *releaseEvent)
+{
+    Qt::MouseButton button = translateMouseButton(releaseEvent->detail);
+
+    // Skip the event if it wasn't a left mouse release
+    if (button != Qt::LeftButton) {
+        return false;
+    }
+
+    QPoint windowPos(releaseEvent->event_x, releaseEvent->event_y);
+
+    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(releaseEvent->event));
+
+    // no autoCommit
+    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice, false);
+    touchEvent.release(0, windowPos);
+    // do not process events when committed, let the events be processed with next event loop
+    touchEvent.commit(false);
+
+    m_leftButtonIsPressed = false;
+    return true;
+}
+
+bool MouseTouchAdaptor::handleMotionNotify(xcb_motion_notify_event_t *event)
+{
+    if (!m_leftButtonIsPressed) {
+        return false;
+    }
+
+    QPoint windowPos(event->event_x, event->event_y);
+
+    QWindow *targetWindow = findQWindowWithXWindowID(static_cast<WId>(event->event));
+
+    // no autoCommit
+    QTouchEventSequence touchEvent = QTest::touchEvent(targetWindow, m_touchDevice, false);
+    touchEvent.move(0, windowPos);
+    // do not process events when committed, let the events be processed with next event loop
+    touchEvent.commit(false);
+
+    return true;
+}
+
+QWindow *MouseTouchAdaptor::findQWindowWithXWindowID(WId windowId)
+{
+    QWindowList windowList = QGuiApplication::topLevelWindows();
+    QWindow *foundWindow = 0;
+
+    int i = 0;
+    while (!foundWindow && i < windowList.count()) {
+        QWindow *window = windowList[i];
+        if (window->winId() == windowId) {
+            foundWindow = window;
+        } else {
+            ++i;
+        }
+    }
+
+    Q_ASSERT(foundWindow);
+    return foundWindow;
+}
 
=== added file 'tests/launcher/MouseTouchAdaptor.h'
--- tests/launcher/MouseTouchAdaptor.h	1970-01-01 00:00:00 +0000
+++ tests/launcher/MouseTouchAdaptor.h	2014-06-25 19:24:49 +0000
@@ -0,0 +1,50 @@
+/*
+ * Copyright 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 as published by
+ * the Free Software Foundation; version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Daniel d'Andrada <[e-mail]>
+ *
+ */
+
+#ifndef MOUSE_TOUCH_ADAPTOR_H
+#define MOUSE_TOUCH_ADAPTOR_H
+
+#include <QtCore/QAbstractNativeEventFilter>
+#include <QWindow>
+#include <xcb/xcb.h>
+
+class QMouseEvent;
+class QTouchDevice;
+
+// Transforms QMouseEvents into single-finger QTouchEvents.
+class MouseTouchAdaptor : public QAbstractNativeEventFilter {
+
+public:
+    MouseTouchAdaptor();
+
+    // Filters mouse events and posts the equivalent QTouchEvents.
+    virtual bool nativeEventFilter(const QByteArray & eventType, void *message, long *result);
+
+private:
+
+    bool handleButtonPress(xcb_button_press_event_t *pressEvent);
+    bool handleButtonRelease(xcb_button_release_event_t *releaseEvent);
+    bool handleMotionNotify(xcb_motion_notify_event_t *event);
+    QWindow *findQWindowWithXWindowID(WId windowId);
+
+    QTouchDevice *m_touchDevice;
+    bool m_leftButtonIsPressed;
+};
+
+#endif // MOUSE_TOUCH_ADAPTOR_H
 
=== modified file 'tests/launcher/launcher.cpp'
--- tests/launcher/launcher.cpp	2014-06-09 08:26:24 +0000
+++ tests/launcher/launcher.cpp	2014-06-25 19:24:49 +0000
@@ -30,16 +30,18 @@
 #include <QOpenGLContext>
 #include <QtGui/private/qopenglcontext_p.h>
 #include <QtQuick/private/qsgcontext_p.h>
+#include <QtCore/QCommandLineParser>
+#include <QtCore/QCommandLineOption>
+#include "MouseTouchAdaptor.h"
+#include <QtGui/QTouchDevice>
 
-int usage()
+bool touchDevicePresent()
 {
-    QString self(QGuiApplication::instance()->arguments().at(0));
-    std::cout << "Usage\n  "
-        << qPrintable(self)
-        << " -testability -frameless -engine"
-        << " --desktop_file_path=DESKTOP_FILE"
-        << " -I MODULE_PATH FILENAME\n";
-    return 1;
+    Q_FOREACH(const QTouchDevice *device, QTouchDevice::devices()) {
+        if (device->type() == QTouchDevice::TouchScreen)
+            return true;
+    }
+    return false;
 }
 
 int main(int argc, const char *argv[])
@@ -58,25 +60,40 @@
 #endif
     QGuiApplication::setApplicationName("UITK Launcher");
     QGuiApplication application(argc, (char**)argv);
-    QStringList args (application.arguments());
-
-    int _testability(args.indexOf("-testability"));
-    args.removeAt(_testability);
-    int _frameless(args.indexOf("-frameless"));
-    args.removeAt(_frameless);
-    int _engine(args.indexOf("-engine"));
-    args.removeAt(_engine);
-
-    Q_FOREACH(QString arg, args) {
-        if (arg.startsWith("--desktop_file_hint")) {
-            // This will not be used - it only needs to be ignored
-            int _desktop_file_hint(args.indexOf(arg));
-            args.removeAt(_desktop_file_hint);
-        }
+
+    QCommandLineParser args;
+    QCommandLineOption _import("I", "Add <path> to the list of import paths", "path");
+    QCommandLineOption _enableTouch("touch", "Enables mouse to touch conversion on desktop");
+    QCommandLineOption _testability("testability", "Loads the testability driver");
+    QCommandLineOption _frameless("frameless", "Run without borders");
+    QCommandLineOption _engine("engine", "Use quick engine from quick view");
+    QCommandLineOption _desktop_file_hint("desktop_file_hint", "Desktop file - ignored", "desktop_file");
+
+    args.addOption(_import);
+    args.addOption(_enableTouch);
+    args.addOption(_testability);
+    args.addOption(_frameless);
+    args.addOption(_engine);
+    args.addOption(_desktop_file_hint);
+    args.addPositionalArgument("filename", "Document to be viewed");
+    args.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
+    args.addHelpOption();
+    if (!args.parse(application.arguments())) {
+        qWarning() << args.errorText();
+        args.showHelp(1);
+    }
+
+    QString filename;
+    if (args.positionalArguments().count() > 0) {
+        filename = args.positionalArguments()[0];
+    }
+    if (filename.isEmpty()) {
+        // show usage and exit
+        args.showHelp(1);
     }
 
     // Testability is only supported out of the box by QApplication not QGuiApplication
-    if (_testability > -1 || getenv("QT_LOAD_TESTABILITY")) {
+    if (args.isSet(_testability) || getenv("QT_LOAD_TESTABILITY")) {
         QLibrary testLib(QLatin1String("qttestability"));
         if (testLib.load()) {
             typedef void (*TasInitialize)(void);
@@ -96,7 +113,7 @@
     QQmlEngine* engine;
     // The default constructor affects the components tree (autopilot vis)
     QQuickView* view;
-    if (_engine > -1) {
+    if (args.isSet(_engine)) {
         view = new QQuickView();
         engine = view->engine();
     } else {
@@ -104,43 +121,31 @@
         view = new QQuickView(engine, NULL);
     }
 
-    int _import(args.indexOf("-I"));
-    args.removeAt(_import);
-    if (_import > -1) {
-        if (args.count() > _import) {
-            QString importPath(args.at(_import));
-            args.removeAt(_import);
-            engine->addImportPath(importPath);
+    if (args.isSet(_import)) {
+        QStringList paths = args.values(_import);
+        Q_FOREACH(const QString &path, paths) {
+            engine->addImportPath(path);
         }
     }
 
     view->setResizeMode(QQuickView::SizeRootObjectToView);
     view->setTitle("UI Toolkit QQuickView");
-    if (_frameless > -1) {
+    if (args.isSet(_frameless)) {
         view->setFlags(Qt::FramelessWindowHint);
     }
 
-    // The remaining unnamed argument must be a filename
-    if (args.count() == 1) {
-        qCritical() << "Missing filename";
-        return usage();
+    if (args.isSet(_enableTouch) && !touchDevicePresent()) {
+        // has no effect if we have touch screen
+        application.installNativeEventFilter(new MouseTouchAdaptor);
     }
-    QString filename(args.at(1));
-    // The first argument is the launcher itself
-    args.removeAt(0);
 
     QUrl source(QUrl::fromLocalFile(filename));
     view->setSource(source);
     if (view->errors().count() > 0) {
-        return usage();
+        args.showHelp(3);
     }
     view->show();
 
-    if (args.count() > 1) {
-        qCritical() << "Invalid arguments passed" << args;
-        return usage();
-    }
-
     return application.exec();
 }
 
 
=== modified file 'tests/launcher/launcher.pro'
--- tests/launcher/launcher.pro	2014-05-14 11:00:20 +0000
+++ tests/launcher/launcher.pro	2014-06-25 19:24:49 +0000
@@ -1,11 +1,13 @@
 TEMPLATE = app
 QT += qml quick
 # For setSharedOpenGLContext
-QT += core-private gui-private quick-private
+QT += core-private gui-private testlib quick-private
 CONFIG += no_keywords
-SOURCES += \
-    launcher.cpp
-launcher.path = /usr/lib/ubuntu-ui-toolkit
+HEADERS += MouseTouchAdaptor.h
+SOURCES += launcher.cpp \
+    MouseTouchAdaptor.cpp
+installPath = $$[QT_INSTALL_LIBS]/ubuntu-ui-toolkit
+launcher.path = $$installPath
 launcher.files = launcher
 INSTALLS += launcher
 
 
=== modified file 'tests/qmlapicheck.sh'
--- tests/qmlapicheck.sh	2014-04-23 13:45:41 +0000
+++ tests/qmlapicheck.sh	2014-06-25 19:24:49 +0000
@@ -16,7 +16,7 @@
 #
 ################################################################################
 QML="modules/Ubuntu/*/qmldir modules/Ubuntu/Components/Colors/UbuntuColors.qml modules/Ubuntu/Components/*/qmldir modules/Ubuntu/Components/Pickers/PickerPanel.qml"
-CPP="Ubuntu.Components Ubuntu.Layouts Ubuntu.PerformanceMetrics"
+CPP="Ubuntu.Components Ubuntu.Layouts Ubuntu.PerformanceMetrics Ubuntu.Test"
 
 echo Dumping QML API of C++ components
 echo '' > plugins.qmltypes
 
=== modified file 'tests/unit/tst_components/tst_label.qml'
--- tests/unit/tst_components/tst_label.qml	2014-05-26 10:13:41 +0000
+++ tests/unit/tst_components/tst_label.qml	2014-06-25 19:24:49 +0000
@@ -21,6 +21,11 @@
 TestCase {
     name: "LabelAPI"
 
+    function test_0_defaults() {
+        compare(textCustom.font.family, "Ubuntu", "Default font family");
+        compare(textCustom.font.weight, Font.Light, "Default font weight");
+    }
+
     function test_fontSize() {
         compare(textCustom.fontSize,"medium","fontSize is 'medium' by default")
 
 
=== modified file 'tests/unit_x11/tst_components/tst_textarea.qml'
--- tests/unit_x11/tst_components/tst_textarea.qml	2014-06-10 14:22:42 +0000
+++ tests/unit_x11/tst_components/tst_textarea.qml	2014-06-25 19:24:49 +0000
@@ -705,6 +705,7 @@
         }
 
         function test_clear_selection_by_click_beside_selection() {
+            skip("The test fails and will be overruled by future UX.");
             longText.focus = true;
             var handler = findChild(longText, "input_handler");
             var y = longText.height / 2;
 
=== modified file 'tests/unit_x11/tst_inversemousearea/tst_inversemouseareatest.cpp'
--- tests/unit_x11/tst_inversemousearea/tst_inversemouseareatest.cpp	2014-06-11 11:24:39 +0000
+++ tests/unit_x11/tst_inversemousearea/tst_inversemouseareatest.cpp	2014-06-25 19:24:49 +0000
@@ -22,7 +22,7 @@
 #include <QtQuick/QQuickItem>
 #include <QtCore/QEvent>
 
-#include "uctestcase.h"
+#include "uctestextras.h"
 #include "inversemouseareatype.h"
 #include "ucunits.h"
 #include <private/qquickevents_p_p.h>
@@ -89,7 +89,7 @@
     void initTestCase()
     {
         // make sure we have a touch device installed
-        UbuntuTestCase::registerTouchDevice();
+        UCTestExtras::registerTouchDevice();
         QString modules("../../../modules");
         QVERIFY(QDir(modules).exists());
 
@@ -513,7 +513,7 @@
         QCOMPARE(imaSpy.count(), 1);
 
         imaSpy.clear();
-        UbuntuTestCase::touchClick(0, quickView, guPoint(20, 5));
+        UCTestExtras::touchClick(0, quickView->rootObject(), guPoint(20, 5));
         QCOMPARE(imaSpy.count(), 1);
     }
 
 
=== modified file 'tests/unit_x11/tst_test/tst_ubuntutestcase.qml'
--- tests/unit_x11/tst_test/tst_ubuntutestcase.qml	2014-04-20 19:25:12 +0000
+++ tests/unit_x11/tst_test/tst_ubuntutestcase.qml	2014-06-25 19:24:49 +0000
@@ -25,11 +25,19 @@
 
  Column {
      anchors.fill: parent
+     MultiPointTouchArea {
+         id: topTouchArea
+         width: parent.width
+         height: 100
+         touchPoints: TouchPoint {
+//             id: point
+         }
+     }
      MouseArea {
         id: mouseArea
         objectName: "myMouseArea"
         width: parent.width
-        height: 300
+        height: 200
         hoverEnabled: true
         acceptedButtons: Qt.LeftButton | Qt.MiddleButton | Qt.RightButton
         property int testX : 0
@@ -42,6 +50,15 @@
            steps++;
         }
      }
+     MultiPointTouchArea {
+         id: touchArea
+         width: parent.width
+         height: 100
+         touchPoints: TouchPoint {
+             id: point
+         }
+     }
+
      Flickable {
          id: flicker
          width: parent.width
@@ -62,18 +79,28 @@
     name: "TestTheUbuntuTestCase"
     when: windowShown
 
+    function initTestCase() {
+        TestExtras.registerTouchDevice();
+    }
+
     function init() {
         mouseArea.steps = 0;
     }
     function cleanup() {
         movementSpy.clear();
         longPressSpy.clear();
+        touchPressSpy.clear();
+        touchReleaseSpy.clear();
+        touchUpdateSpy.clear();
+        touchPressSpy.target = null;
+        touchReleaseSpy.target = null;
+        touchUpdateSpy.target = null;
     }
 
     function test_mouseMoveSlowly() {
-       mouseMoveSlowly(root,0,0,800,300,10,100);
+       mouseMoveSlowly(mouseArea,0,0,800,200,10,100);
        compare(mouseArea.testX,800);
-       compare(mouseArea.testY,300);
+       compare(mouseArea.testY,200);
        compare(mouseArea.steps,10);
     }
 
@@ -146,5 +173,129 @@
         flick(flicker, flicker.width, flicker.height, -flicker.width, -flicker.height, 400, 100);
         movementSpy.wait();
     }
+
+    SignalSpy {
+        id: touchPressSpy
+        signalName: "onPressed"
+        target: touchArea
+    }
+    SignalSpy {
+        id: touchReleaseSpy
+        signalName: "onReleased"
+        target: touchArea
+    }
+    SignalSpy {
+        id: touchUpdateSpy
+        signalName: "onUpdated"
+        target: touchArea
+    }
+
+    function test_has_property() {
+        verify(TestExtras.hasOwnProperty("touchPresent"), "touchPresent property missing");
+    }
+
+    function test_touchPress_data() {
+        return [
+            {touch: touchArea},
+            {touch: topTouchArea}
+        ];
+    }
+    function test_touchPress(data) {
+        touchPressSpy.target = data.touch;
+        TestExtras.touchPress(0, data.touch, Qt.point(10, 10));
+        touchPressSpy.wait();
+        // cleanup
+        TestExtras.touchRelease(0, data.touch, Qt.point(10, 10));
+    }
+
+    function test_touchRelease_data() {
+        return [
+            {touch: touchArea},
+            {touch: topTouchArea}
+        ];
+    }
+    function test_touchRelease(data) {
+        // prerequisite: do a press so we get a release
+        TestExtras.touchPress(0, data.touch, Qt.point(10, 10));
+
+        touchReleaseSpy.target = data.touch;
+        TestExtras.touchRelease(0, data.touch, Qt.point(10, 10));
+        touchReleaseSpy.wait();
+    }
+
+    function test_touchClick_data() {
+        return [
+            {touch: touchArea},
+            {touch: topTouchArea}
+        ];
+    }
+    function test_touchClick(data) {
+        touchPressSpy.target = data.touch;
+        touchReleaseSpy.target = data.touch;
+        TestExtras.touchClick(0, data.touch, Qt.point(10, 10));
+        touchReleaseSpy.wait();
+        compare(touchPressSpy.count, 1, "Not pressed?");
+        compare(touchReleaseSpy.count, 1, "Not released?");
+    }
+
+    function test_touchDoubleClick_data() {
+        return [
+            {touch: touchArea},
+            {touch: topTouchArea}
+        ];
+    }
+    function test_touchDoubleClick(data) {
+        touchPressSpy.target = data.touch;
+        touchReleaseSpy.target = data.touch;
+        TestExtras.touchDoubleClick(0, data.touch, Qt.point(10, 10));
+        compare(touchPressSpy.count, 2, "Not pressed twice?");
+        compare(touchReleaseSpy.count, 2, "Not released twice?");
+    }
+
+    function test_touchMove_data() {
+        return [
+            {touch: touchArea},
+            {touch: topTouchArea}
+        ];
+    }
+    function test_touchMove(data) {
+        touchUpdateSpy.target = data.touch;
+        TestExtras.touchPress(0, data.touch, Qt.point(0, 0));
+        TestExtras.touchMove(0, data.touch, Qt.point(10, 10));
+        touchUpdateSpy.wait();
+        TestExtras.touchRelease(0, data.touch, Qt.point(10, 10));
+    }
+
+    function test_touchDrag_default_steps_data() {
+        return [
+            {touch: touchArea},
+            {touch: topTouchArea}
+        ];
+    }
+    function test_touchDrag_default_steps(data) {
+        touchPressSpy.target = data.touch;
+        touchReleaseSpy.target = data.touch;
+        touchUpdateSpy.target = data.touch;
+        TestExtras.touchDrag(0, data.touch, Qt.point(0, 0), Qt.point(10, 10));
+        compare(touchPressSpy.count, 1, "Not pressed?");
+        compare(touchReleaseSpy.count, 1, "Not released?");
+        compare(touchUpdateSpy.count, 5, "Not moved?");
+    }
+
+    function test_touchDrag_10_steps_data() {
+        return [
+            {touch: touchArea},
+            {touch: topTouchArea}
+        ];
+    }
+    function test_touchDrag_10_steps(data) {
+        touchPressSpy.target = data.touch;
+        touchReleaseSpy.target = data.touch;
+        touchUpdateSpy.target = data.touch;
+        TestExtras.touchDrag(0, data.touch, Qt.point(0, 0), Qt.point(100, 100), 10);
+        compare(touchPressSpy.count, 1, "Not pressed?");
+        compare(touchReleaseSpy.count, 1, "Not released?");
+        compare(touchUpdateSpy.count, 10, "Not moved?");
+    }
  }
 }