Also test touch in client events test

Following the same pattern as for mouse and keyboard, also test touch events.

Change-Id: Ie84aa0ffe0b0f4f66e9f40207c63d94e32f6dbaf
Reviewed-by: Paul Olav Tvete <paul.tvete@qt.io>

5 files changed, 164 insertions, 1 deletions

diff --git a/tests/auto/client/mockcompositor.cpp b/tests/auto/client/mockcompositor.cpp
index 2f73734f1..682452262 100644
--- a/tests/auto/client/mockcompositor.cpp
+++ b/tests/auto/client/mockcompositor.cpp
@@ -122,6 +122,34 @@ void MockCompositor::sendKeyRelease(const QSharedPointer<MockSurface> &surface,
     processCommand(command);
 }
 
+void MockCompositor::sendTouchDown(const QSharedPointer<MockSurface> &surface, const QPoint &position, int id)
+{
+    Command command = makeCommand(Impl::Compositor::sendTouchDown, m_compositor);
+    command.parameters << QVariant::fromValue(surface) << position << id;
+    processCommand(command);
+}
+
+void MockCompositor::sendTouchMotion(const QSharedPointer<MockSurface> &surface, const QPoint &position, int id)
+{
+    Command command = makeCommand(Impl::Compositor::sendTouchMotion, m_compositor);
+    command.parameters << QVariant::fromValue(surface) << position << id;
+    processCommand(command);
+}
+
+void MockCompositor::sendTouchUp(const QSharedPointer<MockSurface> &surface, int id)
+{
+    Command command = makeCommand(Impl::Compositor::sendTouchUp, m_compositor);
+    command.parameters << QVariant::fromValue(surface) << id;
+    processCommand(command);
+}
+
+void MockCompositor::sendTouchFrame(const QSharedPointer<MockSurface> &surface)
+{
+    Command command = makeCommand(Impl::Compositor::sendTouchFrame, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    processCommand(command);
+}
+
 QSharedPointer<MockSurface> MockCompositor::surface()
 {
     QSharedPointer<MockSurface> result;
@@ -208,6 +236,7 @@ Compositor::Compositor()
     m_seat.reset(new Seat(this, m_display));
     m_pointer = m_seat->pointer();
     m_keyboard = m_seat->keyboard();
+    m_touch = m_seat->touch();
 
     wl_display_add_global(m_display, &wl_output_interface, this, bindOutput);
     wl_display_add_global(m_display, &wl_shell_interface, this, bindShell);
diff --git a/tests/auto/client/mockcompositor.h b/tests/auto/client/mockcompositor.h
index cf3b270a2..8731949c0 100644
--- a/tests/auto/client/mockcompositor.h
+++ b/tests/auto/client/mockcompositor.h
@@ -52,6 +52,7 @@ typedef void (**Implementation)(void);
 
 class Keyboard;
 class Pointer;
+class Touch;
 class Seat;
 class DataDeviceManager;
 class Surface;
@@ -80,6 +81,10 @@ public:
     static void sendMouseRelease(void *data, const QList<QVariant> &parameters);
     static void sendKeyPress(void *data, const QList<QVariant> &parameters);
     static void sendKeyRelease(void *data, const QList<QVariant> &parameters);
+    static void sendTouchDown(void *data, const QList<QVariant> &parameters);
+    static void sendTouchUp(void *data, const QList<QVariant> &parameters);
+    static void sendTouchMotion(void *data, const QList<QVariant> &parameters);
+    static void sendTouchFrame(void *data, const QList<QVariant> &parameters);
 
 private:
     static void bindCompositor(wl_client *client, void *data, uint32_t version, uint32_t id);
@@ -104,6 +109,7 @@ private:
     QScopedPointer<Seat> m_seat;
     Pointer *m_pointer;
     Keyboard *m_keyboard;
+    Touch *m_touch;
     QScopedPointer<DataDeviceManager> m_data_device_manager;
     QVector<Surface *> m_surfaces;
 };
@@ -146,6 +152,10 @@ public:
     void sendMouseRelease(const QSharedPointer<MockSurface> &surface);
     void sendKeyPress(const QSharedPointer<MockSurface> &surface, uint code);
     void sendKeyRelease(const QSharedPointer<MockSurface> &surface, uint code);
+    void sendTouchDown(const QSharedPointer<MockSurface> &surface, const QPoint &position, int id);
+    void sendTouchMotion(const QSharedPointer<MockSurface> &surface, const QPoint &position, int id);
+    void sendTouchUp(const QSharedPointer<MockSurface> &surface, int id);
+    void sendTouchFrame(const QSharedPointer<MockSurface> &surface);
 
     QSharedPointer<MockSurface> surface();
 
diff --git a/tests/auto/client/mockinput.cpp b/tests/auto/client/mockinput.cpp
index 5b1d4f4fd..dd0512e76 100644
--- a/tests/auto/client/mockinput.cpp
+++ b/tests/auto/client/mockinput.cpp
@@ -92,11 +92,64 @@ void Compositor::sendKeyRelease(void *data, const QList<QVariant> &parameters)
     compositor->m_keyboard->sendKey(parameters.last().toUInt() - 8, 0);
 }
 
+void Compositor::sendTouchDown(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+
+    Q_ASSERT(compositor);
+    Q_ASSERT(surface);
+
+    QPoint position = parameters.at(1).toPoint();
+    int id = parameters.at(2).toInt();
+
+    compositor->m_touch->sendDown(surface, position, id);
+}
+
+void Compositor::sendTouchUp(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+
+    Q_ASSERT(compositor);
+    Q_ASSERT(surface);
+
+    int id = parameters.at(1).toInt();
+
+    compositor->m_touch->sendUp(surface, id);
+}
+
+void Compositor::sendTouchMotion(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+
+    Q_ASSERT(compositor);
+    Q_ASSERT(surface);
+
+    QPoint position = parameters.at(1).toPoint();
+    int id = parameters.at(2).toInt();
+
+    compositor->m_touch->sendMotion(surface, position, id);
+}
+
+void Compositor::sendTouchFrame(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+
+    Q_ASSERT(compositor);
+    Q_ASSERT(surface);
+
+    compositor->m_touch->sendFrame(surface);
+}
+
 Seat::Seat(Compositor *compositor, struct ::wl_display *display)
     : wl_seat(display, 2)
     , m_compositor(compositor)
     , m_keyboard(new Keyboard(compositor))
     , m_pointer(new Pointer(compositor))
+    , m_touch(new Touch(compositor))
 {
 }
 
@@ -106,7 +159,7 @@ Seat::~Seat()
 
 void Seat::seat_bind_resource(Resource *resource)
 {
-    send_capabilities(resource->handle, capability_keyboard | capability_pointer);
+    send_capabilities(resource->handle, capability_keyboard | capability_pointer | capability_touch);
 }
 
 void Seat::seat_get_keyboard(Resource *resource, uint32_t id)
@@ -119,6 +172,11 @@ void Seat::seat_get_pointer(Resource *resource, uint32_t id)
     m_pointer->add(resource->client(), id, resource->version());
 }
 
+void Seat::seat_get_touch(Resource *resource, uint32_t id)
+{
+    m_touch->add(resource->client(), id, resource->version());
+}
+
 Keyboard::Keyboard(Compositor *compositor)
     : wl_keyboard()
     , m_compositor(compositor)
@@ -219,6 +277,41 @@ void Pointer::pointer_destroy_resource(wl_pointer::Resource *resource)
         m_focusResource = 0;
 }
 
+Touch::Touch(Compositor *compositor)
+    : wl_touch()
+    , m_compositor(compositor)
+{
+}
+
+void Touch::sendDown(Surface *surface, const QPoint &position, int id)
+{
+    uint32_t serial = m_compositor->nextSerial();
+    uint32_t time = m_compositor->time();
+    Q_ASSERT(surface);
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    Q_ASSERT(resource);
+    wl_touch_send_down(resource->handle, serial, time, surface->resource()->handle, id, position.x(), position.y());
+}
+
+void Touch::sendUp(Surface *surface, int id)
+{
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    wl_touch_send_up(resource->handle, m_compositor->nextSerial(), m_compositor->time(), id);
+}
+
+void Touch::sendMotion(Surface *surface, const QPoint &position, int id)
+{
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    uint32_t time = m_compositor->time();
+    wl_touch_send_motion(resource->handle, time, id, position.x(), position.y());
+}
+
+void Touch::sendFrame(Surface *surface)
+{
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    wl_touch_send_frame(resource->handle);
+}
+
 DataDevice::DataDevice(Compositor *compositor)
     : wl_data_device()
     , m_compositor(compositor)
diff --git a/tests/auto/client/mockinput.h b/tests/auto/client/mockinput.h
index 7d36a5325..61c507077 100644
--- a/tests/auto/client/mockinput.h
+++ b/tests/auto/client/mockinput.h
@@ -56,17 +56,20 @@ public:
 
     Keyboard *keyboard() const { return m_keyboard.data(); }
     Pointer *pointer() const { return m_pointer.data(); }
+    Touch *touch() const { return m_touch.data(); }
 
 protected:
     void seat_bind_resource(Resource *resource) Q_DECL_OVERRIDE;
     void seat_get_keyboard(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
     void seat_get_pointer(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
+    void seat_get_touch(Resource *resource, uint32_t id) Q_DECL_OVERRIDE;
 
 private:
     Compositor *m_compositor;
 
     QScopedPointer<Keyboard> m_keyboard;
     QScopedPointer<Pointer> m_pointer;
+    QScopedPointer<Touch> m_touch;
 };
 
 class Keyboard : public QtWaylandServer::wl_keyboard
@@ -112,6 +115,18 @@ private:
     Surface *m_focus;
 };
 
+class Touch : public QtWaylandServer::wl_touch
+{
+public:
+    Touch(Compositor *compositor);
+    void sendDown(Surface *surface, const QPoint &position, int id);
+    void sendUp(Surface *surface, int id);
+    void sendMotion(Surface *surface, const QPoint &position, int id);
+    void sendFrame(Surface *surface);
+private:
+    Compositor *m_compositor;
+};
+
 class DataDevice : public QtWaylandServer::wl_data_device
 {
 public:
diff --git a/tests/auto/client/tst_client.cpp b/tests/auto/client/tst_client.cpp
index dd35b681c..3fde258d1 100644
--- a/tests/auto/client/tst_client.cpp
+++ b/tests/auto/client/tst_client.cpp
@@ -51,6 +51,7 @@ public:
         , keyReleaseEventCount(0)
         , mousePressEventCount(0)
         , mouseReleaseEventCount(0)
+        , touchEventCount(0)
         , keyCode(0)
     {
         setSurfaceType(QSurface::RasterSurface);
@@ -91,12 +92,18 @@ public:
         ++mouseReleaseEventCount;
     }
 
+    void touchEvent(QTouchEvent *event) Q_DECL_OVERRIDE
+    {
+        ++touchEventCount;
+    }
+
     int focusInEventCount;
     int focusOutEventCount;
     int keyPressEventCount;
     int keyReleaseEventCount;
     int mousePressEventCount;
     int mouseReleaseEventCount;
+    int touchEventCount;
 
     uint keyCode;
     QPoint mousePressPos;
@@ -197,6 +204,15 @@ void tst_WaylandClient::events()
     QCOMPARE(window.mouseReleaseEventCount, 0);
     compositor->sendMouseRelease(surface);
     QTRY_COMPARE(window.mouseReleaseEventCount, 1);
+
+    const int touchId = 0;
+    compositor->sendTouchDown(surface, QPoint(10, 10), touchId);
+    compositor->sendTouchFrame(surface);
+    QTRY_COMPARE(window.touchEventCount, 1);
+
+    compositor->sendTouchUp(surface, touchId);
+    compositor->sendTouchFrame(surface);
+    QTRY_COMPARE(window.touchEventCount, 2);
 }
 
 void tst_WaylandClient::backingStore()