17 files changed, 2593 insertions, 0 deletions

diff --git a/tests/auto/client/shared_old/mockcompositor.cpp b/tests/auto/client/shared_old/mockcompositor.cpp
new file mode 100644
index 000000000..df24b4091
--- /dev/null
+++ b/tests/auto/client/shared_old/mockcompositor.cpp
@@ -0,0 +1,520 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mockcompositor.h"
+#include "mockinput.h"
+#include "mockoutput.h"
+#include "mocksurface.h"
+#include "mockwlshell.h"
+#include "mockxdgshellv6.h"
+#include "mockiviapplication.h"
+
+#include <wayland-xdg-shell-unstable-v6-server-protocol.h>
+
+#include <stdio.h>
+MockCompositor::MockCompositor()
+{
+    pthread_create(&m_thread, 0, run, this);
+
+    m_mutex.lock();
+    m_waitCondition.wait(&m_mutex);
+    m_mutex.unlock();
+}
+
+MockCompositor::~MockCompositor()
+{
+    m_alive = false;
+    m_waitCondition.wakeOne();
+    pthread_join(m_thread, 0);
+}
+
+void MockCompositor::lock()
+{
+    m_mutex.lock();
+}
+
+void MockCompositor::unlock()
+{
+    m_mutex.unlock();
+}
+
+void MockCompositor::applicationInitialized()
+{
+    m_ready = true;
+}
+
+int MockCompositor::waylandFileDescriptor() const
+{
+    return m_compositor->fileDescriptor();
+}
+
+void MockCompositor::processWaylandEvents()
+{
+    m_waitCondition.wakeOne();
+}
+
+void MockCompositor::setOutputMode(const QSize &size)
+{
+    Command command = makeCommand(Impl::Compositor::setOutputMode, m_compositor);
+    command.parameters << size;
+    processCommand(command);
+}
+
+void MockCompositor::setKeyboardFocus(const QSharedPointer<MockSurface> &surface)
+{
+    Command command = makeCommand(Impl::Compositor::setKeyboardFocus, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    processCommand(command);
+}
+
+void MockCompositor::sendMousePress(const QSharedPointer<MockSurface> &surface, const QPoint &pos)
+{
+    Command command = makeCommand(Impl::Compositor::sendMousePress, m_compositor);
+    command.parameters << QVariant::fromValue(surface) << pos;
+    processCommand(command);
+}
+
+void MockCompositor::sendMouseRelease(const QSharedPointer<MockSurface> &surface)
+{
+    Command command = makeCommand(Impl::Compositor::sendMouseRelease, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    processCommand(command);
+}
+
+void MockCompositor::sendKeyPress(const QSharedPointer<MockSurface> &surface, uint code)
+{
+    Command command = makeCommand(Impl::Compositor::sendKeyPress, m_compositor);
+    command.parameters << QVariant::fromValue(surface) << code;
+    processCommand(command);
+}
+
+void MockCompositor::sendKeyRelease(const QSharedPointer<MockSurface> &surface, uint code)
+{
+    Command command = makeCommand(Impl::Compositor::sendKeyRelease, m_compositor);
+    command.parameters << QVariant::fromValue(surface) << code;
+    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);
+}
+
+void MockCompositor::sendDataDeviceDataOffer(const QSharedPointer<MockSurface> &surface)
+{
+    Command command = makeCommand(Impl::Compositor::sendDataDeviceDataOffer, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    processCommand(command);
+}
+
+void MockCompositor::sendDataDeviceEnter(const QSharedPointer<MockSurface> &surface, const QPoint& position)
+{
+    Command command = makeCommand(Impl::Compositor::sendDataDeviceEnter, m_compositor);
+    command.parameters << QVariant::fromValue(surface) << QVariant::fromValue(position);
+    processCommand(command);
+}
+
+void MockCompositor::sendDataDeviceMotion(const QPoint &position)
+{
+    Command command = makeCommand(Impl::Compositor::sendDataDeviceMotion, m_compositor);
+    command.parameters << QVariant::fromValue(position);
+    processCommand(command);
+}
+
+void MockCompositor::sendDataDeviceDrop(const QSharedPointer<MockSurface> &surface)
+{
+    Command command = makeCommand(Impl::Compositor::sendDataDeviceDrop, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    processCommand(command);
+}
+
+void MockCompositor::sendDataDeviceLeave(const QSharedPointer<MockSurface> &surface)
+{
+    Command command = makeCommand(Impl::Compositor::sendDataDeviceLeave, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    processCommand(command);
+}
+
+void MockCompositor::sendAddOutput()
+{
+    Command command = makeCommand(Impl::Compositor::sendAddOutput, m_compositor);
+    processCommand(command);
+}
+
+void MockCompositor::sendRemoveOutput(const QSharedPointer<MockOutput> &output)
+{
+    Command command = makeCommand(Impl::Compositor::sendRemoveOutput, m_compositor);
+    command.parameters << QVariant::fromValue(output);
+    processCommand(command);
+}
+
+void MockCompositor::sendOutputGeometry(const QSharedPointer<MockOutput> &output, const QRect &geometry)
+{
+    Command command = makeCommand(Impl::Compositor::sendOutputGeometry, m_compositor);
+    command.parameters << QVariant::fromValue(output);
+    command.parameters << QVariant::fromValue(geometry);
+    processCommand(command);
+}
+
+void MockCompositor::sendSurfaceEnter(const QSharedPointer<MockSurface> &surface, QSharedPointer<MockOutput> &output)
+{
+    Command command = makeCommand(Impl::Compositor::sendSurfaceEnter, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    command.parameters << QVariant::fromValue(output);
+    processCommand(command);
+}
+
+void MockCompositor::sendSurfaceLeave(const QSharedPointer<MockSurface> &surface, QSharedPointer<MockOutput> &output)
+{
+    Command command = makeCommand(Impl::Compositor::sendSurfaceLeave, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    command.parameters << QVariant::fromValue(output);
+    processCommand(command);
+}
+
+void MockCompositor::sendShellSurfaceConfigure(const QSharedPointer<MockSurface> surface, const QSize &size)
+{
+    Command command = makeCommand(Impl::Compositor::sendShellSurfaceConfigure, m_compositor);
+    command.parameters << QVariant::fromValue(surface);
+    command.parameters << QVariant::fromValue(size);
+    processCommand(command);
+}
+
+void MockCompositor::sendIviSurfaceConfigure(const QSharedPointer<MockIviSurface> iviSurface, const QSize &size)
+{
+    Command command = makeCommand(Impl::Compositor::sendIviSurfaceConfigure, m_compositor);
+    command.parameters << QVariant::fromValue(iviSurface);
+    command.parameters << QVariant::fromValue(size);
+    processCommand(command);
+}
+
+void MockCompositor::sendXdgToplevelV6Configure(const QSharedPointer<MockXdgToplevelV6> toplevel, const QSize &size, const QVector<uint> &states)
+{
+    Command command = makeCommand(Impl::Compositor::sendXdgToplevelV6Configure, m_compositor);
+    command.parameters << QVariant::fromValue(toplevel);
+    command.parameters << QVariant::fromValue(size);
+    QByteArray statesBytes(reinterpret_cast<const char *>(states.data()),
+                           states.size() * static_cast<int>(sizeof(uint)));
+    command.parameters << statesBytes;
+    processCommand(command);
+}
+
+void MockCompositor::waitForStartDrag()
+{
+    Command command = makeCommand(Impl::Compositor::waitForStartDrag, m_compositor);
+    processCommand(command);
+}
+
+QSharedPointer<MockSurface> MockCompositor::surface()
+{
+    QSharedPointer<MockSurface> result;
+    lock();
+    QVector<Impl::Surface *> surfaces = m_compositor->surfaces();
+    foreach (Impl::Surface *surface, surfaces) {
+        // we don't want to mistake the cursor surface for a window surface
+        if (surface->isMapped()) {
+            result = surface->mockSurface();
+            break;
+        }
+    }
+    unlock();
+    return result;
+}
+
+QSharedPointer<MockOutput> MockCompositor::output(int index)
+{
+    QSharedPointer<MockOutput> result;
+    lock();
+    if (Impl::Output *output = m_compositor->outputs().value(index, nullptr))
+        result = output->mockOutput();
+    unlock();
+    return result;
+}
+
+QSharedPointer<MockIviSurface> MockCompositor::iviSurface(int index)
+{
+    QSharedPointer<MockIviSurface> result;
+    lock();
+    if (Impl::IviSurface *toplevel = m_compositor->iviApplication()->iviSurfaces().value(index, nullptr))
+        result = toplevel->mockIviSurface();
+    unlock();
+    return result;
+}
+
+QSharedPointer<MockXdgToplevelV6> MockCompositor::xdgToplevelV6(int index)
+{
+    QSharedPointer<MockXdgToplevelV6> result;
+    lock();
+    if (Impl::XdgToplevelV6 *toplevel = m_compositor->xdgShellV6()->toplevels().value(index, nullptr))
+        result = toplevel->mockToplevel();
+    unlock();
+    return result;
+}
+
+QSharedPointer<MockSurface> MockCompositor::fullScreenShellV1Surface(int index)
+{
+    QSharedPointer<MockSurface> result;
+    lock();
+    if (Impl::Surface *surface = m_compositor->fullScreenShellV1()->surfaces().value(index, nullptr))
+        result = surface->mockSurface();
+    unlock();
+    return result;
+}
+
+MockCompositor::Command MockCompositor::makeCommand(Command::Callback callback, void *target)
+{
+    Command command;
+    command.callback = callback;
+    command.target = target;
+    return command;
+}
+
+void MockCompositor::processCommand(const Command &command)
+{
+    lock();
+    m_commandQueue << command;
+    unlock();
+
+    m_waitCondition.wakeOne();
+}
+
+void MockCompositor::dispatchCommands()
+{
+    lock();
+    int count = m_commandQueue.length();
+    unlock();
+
+    for (int i = 0; i < count; ++i) {
+        lock();
+        const Command command = m_commandQueue.takeFirst();
+        unlock();
+        command.callback(command.target, command.parameters);
+    }
+}
+
+void *MockCompositor::run(void *data)
+{
+    MockCompositor *controller = static_cast<MockCompositor *>(data);
+
+    Impl::Compositor compositor;
+
+    controller->m_compositor = &compositor;
+    controller->m_waitCondition.wakeOne();
+
+    while (!controller->m_ready) {
+        controller->dispatchCommands();
+        compositor.dispatchEvents(20);
+    }
+
+    while (controller->m_alive) {
+        {
+            QMutexLocker locker(&controller->m_mutex);
+            if (controller->m_commandQueue.isEmpty())
+                controller->m_waitCondition.wait(&controller->m_mutex);
+        }
+        controller->dispatchCommands();
+        compositor.dispatchEvents(20);
+    }
+
+    return 0;
+}
+
+namespace Impl {
+
+Compositor::Compositor()
+    : m_display(wl_display_create())
+{
+    if (wl_display_add_socket(m_display, 0)) {
+        fprintf(stderr, "Fatal: Failed to open server socket\n");
+        exit(EXIT_FAILURE);
+    }
+
+    wl_global_create(m_display, &wl_compositor_interface, 1, this, bindCompositor);
+
+    m_data_device_manager.reset(new DataDeviceManager(this, m_display));
+
+    wl_display_init_shm(m_display);
+
+    m_seat.reset(new Seat(this, m_display));
+    m_pointer = m_seat->pointer();
+    m_keyboard = m_seat->keyboard();
+    m_touch = m_seat->touch();
+
+    m_outputs.append(new Output(m_display, QSize(1920, 1080), QPoint(0, 0)));
+    m_iviApplication.reset(new IviApplication(m_display));
+    m_wlShell.reset(new WlShell(m_display));
+    m_xdgShellV6.reset(new XdgShellV6(m_display));
+    m_fullScreenShellV1.reset(new FullScreenShellV1(m_display));
+
+    m_loop = wl_display_get_event_loop(m_display);
+    m_fd = wl_event_loop_get_fd(m_loop);
+}
+
+Compositor::~Compositor()
+{
+    wl_display_destroy(m_display);
+}
+
+void Compositor::dispatchEvents(int timeout)
+{
+    wl_display_flush_clients(m_display);
+    wl_event_loop_dispatch(m_loop, timeout);
+}
+
+static void compositor_create_surface(wl_client *client, wl_resource *compositorResource, uint32_t id)
+{
+    Compositor *compositor = static_cast<Compositor *>(wl_resource_get_user_data(compositorResource));
+    compositor->addSurface(new Surface(client, id, wl_resource_get_version(compositorResource), compositor));
+}
+
+static void compositor_create_region(wl_client *client, wl_resource *compositorResource, uint32_t id)
+{
+    Q_UNUSED(client);
+    Q_UNUSED(compositorResource);
+    Q_UNUSED(id);
+}
+
+void Compositor::bindCompositor(wl_client *client, void *compositorData, uint32_t version, uint32_t id)
+{
+    static const struct wl_compositor_interface compositorInterface = {
+        compositor_create_surface,
+        compositor_create_region
+    };
+
+    wl_resource *resource = wl_resource_create(client, &wl_compositor_interface, static_cast<int>(version), id);
+    wl_resource_set_implementation(resource, &compositorInterface, compositorData, nullptr);
+}
+
+static void unregisterResourceCallback(wl_listener *listener, void *data)
+{
+    struct wl_resource *resource = reinterpret_cast<struct wl_resource *>(data);
+    wl_list_remove(wl_resource_get_link(resource));
+    delete listener;
+}
+
+void registerResource(wl_list *list, wl_resource *resource)
+{
+    wl_list_insert(list, wl_resource_get_link(resource));
+
+    wl_listener *listener = new wl_listener;
+    listener->notify = unregisterResourceCallback;
+
+    wl_resource_add_destroy_listener(resource, listener);
+}
+
+QVector<Surface *> Compositor::surfaces() const
+{
+    return m_surfaces;
+}
+
+QVector<Output *> Compositor::outputs() const
+{
+    return m_outputs;
+}
+
+IviApplication *Compositor::iviApplication() const
+{
+    return m_iviApplication.data();
+}
+
+XdgShellV6 *Compositor::xdgShellV6() const
+{
+    return m_xdgShellV6.data();
+}
+
+FullScreenShellV1 *Compositor::fullScreenShellV1() const
+{
+    return m_fullScreenShellV1.data();
+}
+
+uint32_t Compositor::nextSerial()
+{
+    return wl_display_next_serial(m_display);
+}
+
+void Compositor::addSurface(Surface *surface)
+{
+    m_surfaces << surface;
+}
+
+void Compositor::removeSurface(Surface *surface)
+{
+    m_surfaces.removeOne(surface);
+    m_keyboard->handleSurfaceDestroyed(surface);
+    m_pointer->handleSurfaceDestroyed(surface);
+    m_fullScreenShellV1->removeSurface(surface);
+}
+
+Surface *Compositor::resolveSurface(const QVariant &v)
+{
+    QSharedPointer<MockSurface> mockSurface = v.value<QSharedPointer<MockSurface> >();
+    return mockSurface ? mockSurface->handle() : nullptr;
+}
+
+Output *Compositor::resolveOutput(const QVariant &v)
+{
+    QSharedPointer<MockOutput> mockOutput = v.value<QSharedPointer<MockOutput> >();
+    return mockOutput ? mockOutput->handle() : nullptr;
+}
+
+IviSurface *Compositor::resolveIviSurface(const QVariant &v)
+{
+    QSharedPointer<MockIviSurface> mockIviSurface = v.value<QSharedPointer<MockIviSurface>>();
+    return mockIviSurface ? mockIviSurface->handle() : nullptr;
+}
+
+XdgToplevelV6 *Compositor::resolveToplevel(const QVariant &v)
+{
+    QSharedPointer<MockXdgToplevelV6> mockToplevel = v.value<QSharedPointer<MockXdgToplevelV6>>();
+    return mockToplevel ? mockToplevel->handle() : nullptr;
+}
+
+}
diff --git a/tests/auto/client/shared_old/mockcompositor.h b/tests/auto/client/shared_old/mockcompositor.h
new file mode 100644
index 000000000..4bab1ed67
--- /dev/null
+++ b/tests/auto/client/shared_old/mockcompositor.h
@@ -0,0 +1,290 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MOCKCOMPOSITOR_H
+#define MOCKCOMPOSITOR_H
+
+#include "mockxdgshellv6.h"
+#include "mockiviapplication.h"
+#include "mockfullscreenshellv1.h"
+
+#include <pthread.h>
+#include <qglobal.h>
+#include <wayland-server-core.h>
+
+#include <QImage>
+#include <QMutex>
+#include <QRect>
+#include <QSharedPointer>
+#include <QVariant>
+#include <QVector>
+#include <QWaitCondition>
+
+namespace Impl {
+
+typedef void (**Implementation)(void);
+
+class Keyboard;
+class Pointer;
+class Touch;
+class Seat;
+class DataDeviceManager;
+class Surface;
+class Output;
+class IviApplication;
+class WlShell;
+class XdgShellV6;
+
+class Compositor
+{
+public:
+    Compositor();
+    ~Compositor();
+
+    int fileDescriptor() const { return m_fd; }
+    void dispatchEvents(int timeout = 0);
+
+    uint32_t nextSerial();
+    uint32_t time() { return ++m_time; }
+
+    QVector<Surface *> surfaces() const;
+    QVector<Output *> outputs() const;
+
+    IviApplication *iviApplication() const;
+    XdgShellV6 *xdgShellV6() const;
+    FullScreenShellV1 *fullScreenShellV1() const;
+
+    void addSurface(Surface *surface);
+    void removeSurface(Surface *surface);
+
+    static void setKeyboardFocus(void *data, const QList<QVariant> &parameters);
+    static void sendMousePress(void *data, const QList<QVariant> &parameters);
+    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);
+    static void sendDataDeviceDataOffer(void *data, const QList<QVariant> &parameters);
+    static void sendDataDeviceEnter(void *data, const QList<QVariant> &parameters);
+    static void sendDataDeviceMotion(void *data, const QList<QVariant> &parameters);
+    static void sendDataDeviceDrop(void *data, const QList<QVariant> &parameters);
+    static void sendDataDeviceLeave(void *data, const QList<QVariant> &parameters);
+    static void waitForStartDrag(void *data, const QList<QVariant> &parameters);
+    static void setOutputMode(void *compositor, const QList<QVariant> &parameters);
+    static void sendAddOutput(void *data, const QList<QVariant> &parameters);
+    static void sendRemoveOutput(void *data, const QList<QVariant> &parameters);
+    static void sendOutputGeometry(void *data, const QList<QVariant> &parameters);
+    static void sendSurfaceEnter(void *data, const QList<QVariant> &parameters);
+    static void sendSurfaceLeave(void *data, const QList<QVariant> &parameters);
+    static void sendShellSurfaceConfigure(void *data, const QList<QVariant> &parameters);
+    static void sendIviSurfaceConfigure(void *data, const QList<QVariant> &parameters);
+    static void sendXdgToplevelV6Configure(void *data, const QList<QVariant> &parameters);
+
+public:
+    bool m_startDragSeen = false;
+
+private:
+    static void bindCompositor(wl_client *client, void *data, uint32_t version, uint32_t id);
+    static Surface *resolveSurface(const QVariant &v);
+    static Output *resolveOutput(const QVariant &v);
+    static IviSurface *resolveIviSurface(const QVariant &v);
+    static XdgToplevelV6 *resolveToplevel(const QVariant &v);
+
+    void initShm();
+
+    QRect m_outputGeometry;
+
+    wl_display *m_display = nullptr;
+    wl_event_loop *m_loop = nullptr;
+    int m_fd = -1;
+
+    uint32_t m_time = 0;
+
+    QScopedPointer<Seat> m_seat;
+    Pointer *m_pointer = nullptr;
+    Keyboard *m_keyboard = nullptr;
+    Touch *m_touch = nullptr;
+    QScopedPointer<DataDeviceManager> m_data_device_manager;
+    QVector<Surface *> m_surfaces;
+    QVector<Output *> m_outputs;
+    QScopedPointer<IviApplication> m_iviApplication;
+    QScopedPointer<WlShell> m_wlShell;
+    QScopedPointer<XdgShellV6> m_xdgShellV6;
+    QScopedPointer<FullScreenShellV1> m_fullScreenShellV1;
+};
+
+void registerResource(wl_list *list, wl_resource *resource);
+
+}
+
+class MockSurface
+{
+public:
+    Impl::Surface *handle() const { return m_surface; }
+
+    QImage image;
+
+private:
+    MockSurface(Impl::Surface *surface);
+    friend class Impl::Compositor;
+    friend class Impl::Surface;
+
+    Impl::Surface *m_surface = nullptr;
+};
+
+Q_DECLARE_METATYPE(QSharedPointer<MockSurface>)
+
+class MockIviSurface
+{
+public:
+    Impl::IviSurface *handle() const { return m_iviSurface; }
+    const uint iviId;
+
+private:
+    MockIviSurface(Impl::IviSurface *iviSurface) : iviId(iviSurface->iviId()), m_iviSurface(iviSurface) {}
+    friend class Impl::Compositor;
+    friend class Impl::IviSurface;
+
+    Impl::IviSurface *m_iviSurface;
+};
+
+Q_DECLARE_METATYPE(QSharedPointer<MockIviSurface>)
+
+class MockXdgToplevelV6 : public QObject
+{
+    Q_OBJECT
+public:
+    Impl::XdgToplevelV6 *handle() const { return m_toplevel; }
+
+    void sendConfigure(const QSharedPointer<MockXdgToplevelV6> toplevel);
+
+signals:
+    uint setMinimizedRequested();
+    uint setMaximizedRequested();
+    uint unsetMaximizedRequested();
+    uint setFullscreenRequested();
+    uint unsetFullscreenRequested();
+    void windowGeometryRequested(QRect geometry); // NOTE: This is really an xdg surface event
+
+private:
+    MockXdgToplevelV6(Impl::XdgToplevelV6 *toplevel) : m_toplevel(toplevel) {}
+    friend class Impl::Compositor;
+    friend class Impl::XdgToplevelV6;
+
+    Impl::XdgToplevelV6 *m_toplevel;
+};
+
+Q_DECLARE_METATYPE(QSharedPointer<MockXdgToplevelV6>)
+
+class MockOutput {
+public:
+    Impl::Output *handle() const { return m_output; }
+    MockOutput(Impl::Output *output);
+private:
+    Impl::Output *m_output = nullptr;
+};
+
+Q_DECLARE_METATYPE(QSharedPointer<MockOutput>)
+
+class MockCompositor
+{
+public:
+    MockCompositor();
+    ~MockCompositor();
+
+    void applicationInitialized();
+
+    int waylandFileDescriptor() const;
+    void processWaylandEvents();
+
+    void setOutputMode(const QSize &size);
+    void setKeyboardFocus(const QSharedPointer<MockSurface> &surface);
+    void sendMousePress(const QSharedPointer<MockSurface> &surface, const QPoint &pos);
+    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);
+    void sendDataDeviceDataOffer(const QSharedPointer<MockSurface> &surface);
+    void sendDataDeviceEnter(const QSharedPointer<MockSurface> &surface, const QPoint &position);
+    void sendDataDeviceMotion(const QPoint &position);
+    void sendDataDeviceDrop(const QSharedPointer<MockSurface> &surface);
+    void sendDataDeviceLeave(const QSharedPointer<MockSurface> &surface);
+    void sendAddOutput();
+    void sendRemoveOutput(const QSharedPointer<MockOutput> &output);
+    void sendOutputGeometry(const QSharedPointer<MockOutput> &output, const QRect &geometry);
+    void sendSurfaceEnter(const QSharedPointer<MockSurface> &surface, QSharedPointer<MockOutput> &output);
+    void sendSurfaceLeave(const QSharedPointer<MockSurface> &surface, QSharedPointer<MockOutput> &output);
+    void sendShellSurfaceConfigure(const QSharedPointer<MockSurface> surface, const QSize &size = QSize(0, 0));
+    void sendIviSurfaceConfigure(const QSharedPointer<MockIviSurface> iviSurface, const QSize &size);
+    void sendXdgToplevelV6Configure(const QSharedPointer<MockXdgToplevelV6> toplevel, const QSize &size = QSize(0, 0),
+                                    const QVector<uint> &states = { ZXDG_TOPLEVEL_V6_STATE_ACTIVATED });
+    void waitForStartDrag();
+
+    QSharedPointer<MockSurface> surface();
+    QSharedPointer<MockOutput> output(int index = 0);
+    QSharedPointer<MockIviSurface> iviSurface(int index = 0);
+    QSharedPointer<MockXdgToplevelV6> xdgToplevelV6(int index = 0);
+    QSharedPointer<MockSurface> fullScreenShellV1Surface(int index = 0);
+
+    void lock();
+    void unlock();
+
+private:
+    struct Command
+    {
+        typedef void (*Callback)(void *target, const QList<QVariant> &parameters);
+
+        Callback callback;
+        void *target = nullptr;
+        QList<QVariant> parameters;
+    };
+
+    static Command makeCommand(Command::Callback callback, void *target);
+
+    void processCommand(const Command &command);
+    void dispatchCommands();
+
+    static void *run(void *data);
+
+    bool m_alive = true;
+    bool m_ready = false;
+    pthread_t m_thread;
+    QMutex m_mutex;
+    QWaitCondition m_waitCondition;
+
+    Impl::Compositor *m_compositor = nullptr;
+
+    QList<Command> m_commandQueue;
+};
+
+#endif
diff --git a/tests/auto/client/shared_old/mockfullscreenshellv1.cpp b/tests/auto/client/shared_old/mockfullscreenshellv1.cpp
new file mode 100644
index 000000000..22c49cde6
--- /dev/null
+++ b/tests/auto/client/shared_old/mockfullscreenshellv1.cpp
@@ -0,0 +1,43 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mockfullscreenshellv1.h"
+#include "mocksurface.h"
+
+namespace Impl {
+
+void FullScreenShellV1::zwp_fullscreen_shell_v1_present_surface(Resource *resource, struct ::wl_resource *surface, uint32_t method, struct ::wl_resource *output)
+{
+    Q_UNUSED(resource)
+    Q_UNUSED(method)
+    Q_UNUSED(output)
+
+    m_surfaces.append(Surface::fromResource(surface));
+}
+
+} // namespace Impl
diff --git a/tests/auto/client/shared_old/mockfullscreenshellv1.h b/tests/auto/client/shared_old/mockfullscreenshellv1.h
new file mode 100644
index 000000000..819bbc186
--- /dev/null
+++ b/tests/auto/client/shared_old/mockfullscreenshellv1.h
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MOCKFULLSCREENSHELLV1_H
+#define MOCKFULLSCREENSHELLV1_H
+
+#include <qwayland-server-fullscreen-shell-unstable-v1.h>
+
+#include <QVector>
+
+namespace Impl {
+
+class Surface;
+class FullScreenShellV1;
+
+class FullScreenShellV1 : public QtWaylandServer::zwp_fullscreen_shell_v1
+{
+public:
+    explicit FullScreenShellV1(::wl_display *display) : zwp_fullscreen_shell_v1(display, 1) {}
+
+    QVector<Surface *> surfaces() const { return m_surfaces; }
+    void removeSurface(Surface *surface) { m_surfaces.removeOne(surface); }
+
+protected:
+    void zwp_fullscreen_shell_v1_present_surface(Resource *resource, struct ::wl_resource *surface, uint32_t method, struct ::wl_resource *output) override;
+
+private:
+    QVector<Surface *> m_surfaces;
+};
+
+} // namespace Impl
+
+#endif // MOCKFULLSCREENSHELLV1_H
diff --git a/tests/auto/client/shared_old/mockinput.cpp b/tests/auto/client/shared_old/mockinput.cpp
new file mode 100644
index 000000000..8b7592824
--- /dev/null
+++ b/tests/auto/client/shared_old/mockinput.cpp
@@ -0,0 +1,474 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mockcompositor.h"
+#include "mockinput.h"
+#include "mocksurface.h"
+
+namespace Impl {
+
+void Compositor::setKeyboardFocus(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    compositor->m_keyboard->setFocus(resolveSurface(parameters.first()));
+}
+
+void Compositor::sendMousePress(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
+
+    QPoint pos = parameters.last().toPoint();
+    compositor->m_pointer->setFocus(surface, pos);
+    compositor->m_pointer->sendMotion(pos);
+    compositor->m_pointer->sendButton(0x110, 1);
+}
+
+void Compositor::sendMouseRelease(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
+
+    compositor->m_pointer->sendButton(0x110, 0);
+}
+
+void Compositor::sendKeyPress(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
+
+    compositor->m_keyboard->sendKey(parameters.last().toUInt() - 8, 1);
+}
+
+void Compositor::sendKeyRelease(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    if (!surface)
+        return;
+
+    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);
+}
+
+void Compositor::sendDataDeviceDataOffer(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_data_device_manager->dataDevice()->sendDataOffer(surface->resource()->client());
+}
+
+void Compositor::sendDataDeviceEnter(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.first());
+    QPoint position = parameters.at(1).toPoint();
+
+    Q_ASSERT(compositor);
+    Q_ASSERT(surface);
+
+    compositor->m_data_device_manager->dataDevice()->sendEnter(surface, position);
+}
+
+void Compositor::sendDataDeviceMotion(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Q_ASSERT(compositor);
+    QPoint position = parameters.first().toPoint();
+    compositor->m_data_device_manager->dataDevice()->sendMotion(position);
+}
+
+void Compositor::sendDataDeviceDrop(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_data_device_manager->dataDevice()->sendDrop(surface);
+}
+
+void Compositor::sendDataDeviceLeave(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_data_device_manager->dataDevice()->sendLeave(surface);
+}
+
+void Compositor::waitForStartDrag(void *data, const QList<QVariant> &parameters)
+{
+    Q_UNUSED(parameters);
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Q_ASSERT(compositor);
+    while (!compositor->m_startDragSeen) {
+        wl_display_flush_clients(compositor->m_display);
+        wl_event_loop_dispatch(compositor->m_loop, 100);
+    }
+    compositor->m_startDragSeen = false;
+}
+
+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))
+{
+}
+
+Seat::~Seat()
+{
+}
+
+void Seat::seat_bind_resource(Resource *resource)
+{
+    send_capabilities(resource->handle, capability_keyboard | capability_pointer | capability_touch);
+}
+
+void Seat::seat_get_keyboard(Resource *resource, uint32_t id)
+{
+    m_keyboard->add(resource->client(), id, resource->version());
+}
+
+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)
+    : m_compositor(compositor)
+{
+}
+
+Keyboard::~Keyboard()
+{
+}
+
+void Keyboard::setFocus(Surface *surface)
+{
+    if (m_focusResource && m_focus != surface) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_leave(m_focusResource->handle, serial, m_focus->resource()->handle);
+    }
+
+    Resource *resource = surface ? resourceMap().value(surface->resource()->client()) : 0;
+
+    if (resource && (m_focus != surface || m_focusResource != resource)) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_modifiers(resource->handle, serial, 0, 0, 0, 0);
+        send_enter(resource->handle, serial, surface->resource()->handle, QByteArray());
+    }
+
+    m_focusResource = resource;
+    m_focus = surface;
+}
+
+void Keyboard::handleSurfaceDestroyed(Surface *surface)
+{
+    if (surface == m_focus) {
+        m_focusResource = nullptr;
+        m_focus = nullptr;
+    }
+}
+
+void Keyboard::sendKey(uint32_t key, uint32_t state)
+{
+    if (m_focusResource) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_key(m_focusResource->handle, serial, m_compositor->time(), key, state);
+    }
+}
+
+
+void Keyboard::keyboard_destroy_resource(wl_keyboard::Resource *resource)
+{
+    if (m_focusResource == resource)
+        m_focusResource = 0;
+}
+
+Pointer::Pointer(Compositor *compositor)
+    : m_compositor(compositor)
+{
+}
+
+Pointer::~Pointer()
+{
+
+}
+
+void Pointer::setFocus(Surface *surface, const QPoint &pos)
+{
+    if (m_focusResource && m_focus != surface) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_leave(m_focusResource->handle, serial, m_focus->resource()->handle);
+    }
+
+    Resource *resource = surface ? resourceMap().value(surface->resource()->client()) : 0;
+
+    if (resource && (m_focus != surface || resource != m_focusResource)) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_enter(resource->handle, serial, surface->resource()->handle,
+                   wl_fixed_from_int(pos.x()), wl_fixed_from_int(pos.y()));
+    }
+
+    m_focusResource = resource;
+    m_focus = surface;
+}
+
+void Pointer::handleSurfaceDestroyed(Surface *surface)
+{
+    if (m_focus == surface) {
+        m_focus = nullptr;
+        m_focusResource = nullptr;
+    }
+}
+
+void Pointer::sendMotion(const QPoint &pos)
+{
+    if (m_focusResource)
+        send_motion(m_focusResource->handle, m_compositor->time(),
+                    wl_fixed_from_int(pos.x()), wl_fixed_from_int(pos.y()));
+}
+
+void Pointer::sendButton(uint32_t button, uint32_t state)
+{
+    if (m_focusResource) {
+        uint32_t serial = m_compositor->nextSerial();
+        send_button(m_focusResource->handle, serial, m_compositor->time(),
+                    button, state);
+    }
+}
+
+void Pointer::pointer_destroy_resource(wl_pointer::Resource *resource)
+{
+    if (m_focusResource == 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);
+    auto x = wl_fixed_from_int(position.x());
+    auto y = wl_fixed_from_int(position.y());
+    wl_touch_send_down(resource->handle, serial, time, surface->resource()->handle, id, x, 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();
+    auto x = wl_fixed_from_int(position.x());
+    auto y = wl_fixed_from_int(position.y());
+    wl_touch_send_motion(resource->handle, time, id, x, y);
+}
+
+void Touch::sendFrame(Surface *surface)
+{
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    wl_touch_send_frame(resource->handle);
+}
+
+DataOffer::DataOffer()
+    : wl_data_offer()
+{
+
+}
+
+DataDevice::DataDevice(Compositor *compositor)
+    : m_compositor(compositor)
+{
+
+}
+
+void DataDevice::sendDataOffer(wl_client *client)
+{
+    m_dataOffer = new QtWaylandServer::wl_data_offer(client, 0, 1);
+    Resource *resource = resourceMap().value(client);
+    send_data_offer(resource->handle, m_dataOffer->resource()->handle);
+}
+
+void DataDevice::sendEnter(Surface *surface, const QPoint& position)
+{
+    uint serial = m_compositor->nextSerial();
+    m_focus = surface;
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    send_enter(resource->handle, serial, surface->resource()->handle, position.x(), position.y(), m_dataOffer->resource()->handle);
+}
+
+void DataDevice::sendMotion(const QPoint &position)
+{
+    uint32_t time = m_compositor->time();
+    Resource *resource = resourceMap().value(m_focus->resource()->client());
+    send_motion(resource->handle, time, position.x(), position.y());
+}
+
+void DataDevice::sendDrop(Surface *surface)
+{
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    send_drop(resource->handle);
+}
+
+void DataDevice::sendLeave(Surface *surface)
+{
+    Resource *resource = resourceMap().value(surface->resource()->client());
+    send_leave(resource->handle);
+}
+
+DataDevice::~DataDevice()
+{
+
+}
+
+void DataDevice::data_device_start_drag(QtWaylandServer::wl_data_device::Resource *resource, wl_resource *source, wl_resource *origin, wl_resource *icon, uint32_t serial)
+{
+    Q_UNUSED(resource);
+    Q_UNUSED(source);
+    Q_UNUSED(origin);
+    Q_UNUSED(icon);
+    Q_UNUSED(serial);
+    m_compositor->m_startDragSeen = true;
+}
+
+DataDeviceManager::DataDeviceManager(Compositor *compositor, wl_display *display)
+    : wl_data_device_manager(display, 1)
+    , m_compositor(compositor)
+{
+
+}
+
+DataDeviceManager::~DataDeviceManager()
+{
+
+}
+
+DataDevice *DataDeviceManager::dataDevice() const
+{
+    return m_data_device.data();
+}
+
+void DataDeviceManager::data_device_manager_get_data_device(Resource *resource, uint32_t id, struct ::wl_resource *seat)
+{
+    Q_UNUSED(seat);
+    if (!m_data_device)
+        m_data_device.reset(new DataDevice(m_compositor));
+    m_data_device->add(resource->client(), id, 1);
+}
+
+void DataDeviceManager::data_device_manager_create_data_source(QtWaylandServer::wl_data_device_manager::Resource *resource, uint32_t id)
+{
+    new QtWaylandServer::wl_data_source(resource->client(), id, 1);
+}
+
+}
diff --git a/tests/auto/client/shared_old/mockinput.h b/tests/auto/client/shared_old/mockinput.h
new file mode 100644
index 000000000..d9adb3621
--- /dev/null
+++ b/tests/auto/client/shared_old/mockinput.h
@@ -0,0 +1,172 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2016 Klarälvdalens Datakonsult AB (KDAB).
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MOCKINPUT_H
+#define MOCKINPUT_H
+
+#include <qglobal.h>
+
+#include "qwayland-server-wayland.h"
+
+#include "mockcompositor.h"
+
+namespace Impl {
+
+class Keyboard;
+class Pointer;
+
+class Seat : public QtWaylandServer::wl_seat
+{
+public:
+    Seat(Compositor *compositor, struct ::wl_display *display);
+    ~Seat();
+
+    Compositor *compositor() const { return m_compositor; }
+
+    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) override;
+    void seat_get_keyboard(Resource *resource, uint32_t id) override;
+    void seat_get_pointer(Resource *resource, uint32_t id) override;
+    void seat_get_touch(Resource *resource, uint32_t id) override;
+
+private:
+    Compositor *m_compositor = nullptr;
+
+    QScopedPointer<Keyboard> m_keyboard;
+    QScopedPointer<Pointer> m_pointer;
+    QScopedPointer<Touch> m_touch;
+};
+
+class Keyboard : public QtWaylandServer::wl_keyboard
+{
+public:
+    Keyboard(Compositor *compositor);
+    ~Keyboard();
+
+    Surface *focus() const { return m_focus; }
+    void setFocus(Surface *surface);
+    void handleSurfaceDestroyed(Surface *surface);
+
+    void sendKey(uint32_t key, uint32_t state);
+
+protected:
+    void keyboard_destroy_resource(wl_keyboard::Resource *resource) override;
+
+private:
+    Compositor *m_compositor = nullptr;
+
+    Resource *m_focusResource = nullptr;
+    Surface *m_focus = nullptr;
+};
+
+class Pointer : public QtWaylandServer::wl_pointer
+{
+public:
+    Pointer(Compositor *compositor);
+    ~Pointer();
+
+    Surface *focus() const { return m_focus; }
+
+    void setFocus(Surface *surface, const QPoint &pos);
+    void handleSurfaceDestroyed(Surface *surface);
+    void sendMotion(const QPoint &pos);
+    void sendButton(uint32_t button, uint32_t state);
+
+protected:
+    void pointer_destroy_resource(wl_pointer::Resource *resource) override;
+
+private:
+    Compositor *m_compositor = nullptr;
+
+    Resource *m_focusResource = nullptr;
+    Surface *m_focus = nullptr;
+};
+
+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 = nullptr;
+};
+
+class DataOffer : public QtWaylandServer::wl_data_offer
+{
+public:
+    DataOffer();
+};
+
+class DataDevice : public QtWaylandServer::wl_data_device
+{
+public:
+    DataDevice(Compositor *compositor);
+    void sendDataOffer(wl_client *client);
+    void sendEnter(Surface *surface, const QPoint &position);
+    void sendMotion(const QPoint &position);
+    void sendDrop(Surface *surface);
+    void sendLeave(Surface *surface);
+    ~DataDevice();
+
+protected:
+    void data_device_start_drag(Resource *resource, struct ::wl_resource *source, struct ::wl_resource *origin, struct ::wl_resource *icon, uint32_t serial) override;
+
+private:
+    Compositor *m_compositor = nullptr;
+    QtWaylandServer::wl_data_offer *m_dataOffer = nullptr;
+    Surface* m_focus = nullptr;
+};
+
+class DataDeviceManager : public QtWaylandServer::wl_data_device_manager
+{
+public:
+    DataDeviceManager(Compositor *compositor, struct ::wl_display *display);
+    ~DataDeviceManager();
+    DataDevice *dataDevice() const;
+
+protected:
+    void data_device_manager_get_data_device(Resource *resource, uint32_t id, struct ::wl_resource *seat) override;
+    void data_device_manager_create_data_source(Resource *resource, uint32_t id) override;
+
+private:
+    Compositor *m_compositor = nullptr;
+
+    QScopedPointer<DataDevice> m_data_device;
+};
+
+}
+
+#endif // MOCKINPUT_H
diff --git a/tests/auto/client/shared_old/mockiviapplication.cpp b/tests/auto/client/shared_old/mockiviapplication.cpp
new file mode 100644
index 000000000..29a308993
--- /dev/null
+++ b/tests/auto/client/shared_old/mockiviapplication.cpp
@@ -0,0 +1,72 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mockiviapplication.h"
+#include "mocksurface.h"
+#include "mockcompositor.h"
+
+namespace Impl {
+
+void Compositor::sendIviSurfaceConfigure(void *data, const QList<QVariant> &parameters)
+{
+    Q_UNUSED(data);
+    IviSurface *iviSurface = resolveIviSurface(parameters.at(0));
+    Q_ASSERT(iviSurface && iviSurface->resource());
+    QSize size = parameters.at(1).toSize();
+    Q_ASSERT(!size.isEmpty());
+    iviSurface->send_configure(size.width(), size.height());
+}
+
+IviSurface::IviSurface(IviApplication *iviApplication, Surface *surface, uint iviId, wl_client *client, uint32_t id)
+    : QtWaylandServer::ivi_surface(client, id, 1)
+    , m_surface(surface)
+    , m_iviApplication(iviApplication)
+    , m_iviId(iviId)
+    , m_mockIviSurface(new MockIviSurface(this))
+{
+    iviApplication->addIviSurface(this);
+    surface->map();
+}
+
+IviSurface::~IviSurface()
+{
+    m_iviApplication->removeIviSurface(this);
+    m_mockIviSurface->m_iviSurface = nullptr;
+}
+
+void IviSurface::ivi_surface_destroy(Resource *resource)
+{
+    wl_resource_destroy(resource->handle);
+}
+
+void IviApplication::ivi_application_surface_create(Resource *resource, uint32_t ivi_id, ::wl_resource *surface, uint32_t id)
+{
+    new IviSurface(this, Surface::fromResource(surface), ivi_id, resource->client(), id);
+}
+
+} // namespace Impl
diff --git a/tests/auto/client/shared_old/mockiviapplication.h b/tests/auto/client/shared_old/mockiviapplication.h
new file mode 100644
index 000000000..4d65eeaba
--- /dev/null
+++ b/tests/auto/client/shared_old/mockiviapplication.h
@@ -0,0 +1,85 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MOCKIVIAPPLICATION_H
+#define MOCKIVIAPPLICATION_H
+
+#include <qwayland-server-ivi-application.h>
+
+#include <QSharedPointer>
+#include <QVector>
+
+class MockIviSurface;
+
+namespace Impl {
+
+class Surface;
+class IviApplication;
+
+class IviSurface : public QtWaylandServer::ivi_surface
+{
+public:
+    IviSurface(IviApplication *iviApplication, Surface *surface, uint iviId, wl_client *client, uint32_t id);
+    ~IviSurface() override;
+    IviApplication *iviApplication() const { return m_iviApplication; }
+    Surface *surface() const { return m_surface; }
+    uint iviId() const { return m_iviId; }
+
+    QSharedPointer<MockIviSurface> mockIviSurface() const { return m_mockIviSurface; }
+
+protected:
+    void ivi_surface_destroy_resource(Resource *) override { delete this; }
+    void ivi_surface_destroy(Resource *resource) override;
+
+private:
+    Surface *m_surface = nullptr;
+    IviApplication *m_iviApplication = nullptr;
+    const uint m_iviId = 0;
+    QSharedPointer<MockIviSurface> m_mockIviSurface;
+};
+
+class IviApplication : public QtWaylandServer::ivi_application
+{
+public:
+    explicit IviApplication(::wl_display *display) : ivi_application(display, 1) {}
+    QVector<IviSurface *> iviSurfaces() const { return m_iviSurfaces; }
+
+protected:
+    void ivi_application_surface_create(Resource *resource, uint32_t ivi_id, ::wl_resource *surface, uint32_t id) override;
+
+private:
+    void addIviSurface(IviSurface *iviSurface) { m_iviSurfaces.append(iviSurface); }
+    void removeIviSurface(IviSurface *iviSurface) { m_iviSurfaces.removeOne(iviSurface); }
+    QVector<IviSurface *> m_iviSurfaces;
+
+    friend class IviSurface;
+};
+
+} // namespace Impl
+
+#endif // MOCKIVIAPPLICATION_H
diff --git a/tests/auto/client/shared_old/mockoutput.cpp b/tests/auto/client/shared_old/mockoutput.cpp
new file mode 100644
index 000000000..13e0524ad
--- /dev/null
+++ b/tests/auto/client/shared_old/mockoutput.cpp
@@ -0,0 +1,135 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mockcompositor.h"
+#include "mockoutput.h"
+
+#include <QDebug>
+
+namespace Impl {
+
+void Compositor::sendAddOutput(void *data, const QList<QVariant> &parameters) {
+    Q_UNUSED(parameters);
+    Compositor *compositor = static_cast<Compositor *>(data);
+    auto output = new Output(compositor->m_display, QSize(1920, 1200), QPoint(0, 0));
+    compositor->m_outputs.append(output);
+
+    // Wait for the client to bind to the output
+    while (output->resourceMap().isEmpty())
+        compositor->dispatchEvents();
+}
+
+void Compositor::sendRemoveOutput(void *data, const QList<QVariant> &parameters) {
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Q_ASSERT(compositor);
+    Output *output = resolveOutput(parameters.first());
+    Q_ASSERT(output);
+    bool wasRemoved = compositor->m_outputs.removeOne(output);
+    Q_ASSERT(wasRemoved);
+    delete output;
+}
+
+void Compositor::sendOutputGeometry(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Q_ASSERT(compositor);
+    Output *output = resolveOutput(parameters.first());
+    Q_ASSERT(output);
+    QRect geometry = parameters.at(1).toRect();
+    output->sendGeometryAndMode(geometry);
+}
+
+void Compositor::setOutputMode(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    QSize size = parameters.first().toSize();
+    Output *output = compositor->m_outputs.first();
+    Q_ASSERT(output);
+    output->setCurrentMode(size);
+}
+
+Output::Output(wl_display *display, const QSize &resolution, const QPoint &position)
+    : wl_output(display, 2)
+    , m_size(resolution)
+    , m_position(position)
+    , m_physicalSize(520, 320)
+    , m_mockOutput(new MockOutput(this))
+{
+}
+
+void Output::setCurrentMode(const QSize &size)
+{
+    m_size = size;
+    for (Resource *resource : resourceMap()) {
+        sendCurrentMode(resource);
+        send_done(resource->handle);
+    }
+}
+
+void Output::sendGeometryAndMode(const QRect &geometry)
+{
+    m_size = geometry.size();
+    m_position = geometry.topLeft();
+    for (Resource *resource : resourceMap()) {
+        sendGeometry(resource);
+        sendCurrentMode(resource);
+        send_done(resource->handle);
+    }
+}
+
+void Output::output_bind_resource(QtWaylandServer::wl_output::Resource *resource)
+{
+    sendGeometry(resource);
+    sendCurrentMode(resource);
+    send_done(resource->handle);
+}
+
+void Output::sendGeometry(Resource *resource)
+{
+    const int subPixel = 0;
+    const int transform = 0;
+
+    send_geometry(resource->handle,
+                  m_position.x(), m_position.y(),
+                  m_physicalSize.width(), m_physicalSize.height(),
+                  subPixel, "", "", transform );
+}
+
+void Output::sendCurrentMode(Resource *resource)
+{
+    send_mode(resource->handle,
+              WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED,
+              m_size.width(), m_size.height(), 60000);
+}
+
+} // Impl
+
+MockOutput::MockOutput(Impl::Output *output)
+    : m_output(output)
+{
+}
diff --git a/tests/auto/client/shared_old/mockoutput.h b/tests/auto/client/shared_old/mockoutput.h
new file mode 100644
index 000000000..9f261d5d7
--- /dev/null
+++ b/tests/auto/client/shared_old/mockoutput.h
@@ -0,0 +1,63 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MOCKOUTPUT_H
+#define MOCKOUTPUT_H
+
+#include <qglobal.h>
+
+#include "qwayland-server-wayland.h"
+
+#include "mockcompositor.h"
+
+namespace Impl {
+
+class Output : public QtWaylandServer::wl_output
+{
+public:
+    Output(::wl_display *display, const QSize &resolution, const QPoint &position);
+
+    QSharedPointer<MockOutput> mockOutput() const { return m_mockOutput; }
+    void setCurrentMode(const QSize &size);
+    void sendGeometryAndMode(const QRect &geometry);
+
+protected:
+    void output_bind_resource(Resource *resource) override;
+
+private:
+    void sendGeometry(Resource *resource);
+    void sendCurrentMode(Resource *resource);
+    QSize m_size;
+    QPoint m_position;
+    const QSize m_physicalSize;
+    QSharedPointer<MockOutput> m_mockOutput;
+};
+
+}
+
+#endif // MOCKOUTPUT_H
diff --git a/tests/auto/client/shared_old/mocksurface.cpp b/tests/auto/client/shared_old/mocksurface.cpp
new file mode 100644
index 000000000..84dcda6b0
--- /dev/null
+++ b/tests/auto/client/shared_old/mocksurface.cpp
@@ -0,0 +1,191 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mocksurface.h"
+#include "mockoutput.h"
+#include "mockcompositor.h"
+#include "mockwlshell.h"
+
+#include <QDebug>
+
+namespace Impl {
+
+void Compositor::sendSurfaceEnter(void *data, const QList<QVariant> &parameters)
+{
+    Q_UNUSED(data);
+    Surface *surface = resolveSurface(parameters.at(0));
+    Output *output = resolveOutput(parameters.at(1));
+    Q_ASSERT(surface && surface->resource());
+    Q_ASSERT(output);
+    auto outputResources = output->resourceMap().values(surface->resource()->client());
+    Q_ASSERT(!outputResources.isEmpty());
+
+    for (auto outputResource : outputResources)
+        surface->send_enter(outputResource->handle);
+}
+
+void Compositor::sendSurfaceLeave(void *data, const QList<QVariant> &parameters)
+{
+    Q_UNUSED(data);
+    Surface *surface = resolveSurface(parameters.at(0));
+    Output *output = resolveOutput(parameters.at(1));
+    Q_ASSERT(surface && surface->resource());
+    Q_ASSERT(output);
+    auto outputResources = output->resourceMap().values(surface->resource()->client());
+    Q_ASSERT(!outputResources.isEmpty());
+
+    for (auto outputResource : outputResources)
+        surface->send_leave(outputResource->handle);
+}
+
+void Compositor::sendShellSurfaceConfigure(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    Surface *surface = resolveSurface(parameters.at(0));
+    QSize size = parameters.at(1).toSize();
+    Q_ASSERT(size.isValid());
+    if (auto toplevel = surface->xdgToplevelV6()) {
+        QVector<uint> states = { ZXDG_TOPLEVEL_V6_STATE_ACTIVATED };
+        auto statesBytes = QByteArray::fromRawData(reinterpret_cast<const char *>(states.data()),
+                                                   states.size() * static_cast<int>(sizeof(uint)));
+        toplevel->send_configure(size.width(), size.height(), statesBytes);
+        toplevel->xdgSurface()->sendConfigure(compositor->nextSerial());
+    } else if (auto wlShellSurface = surface->wlShellSurface()) {
+        const uint edges = 0;
+        wlShellSurface->send_configure(edges, size.width(), size.height());
+    } else {
+        qWarning() << "The mocking framework doesn't know how to send a configure event for this surface";
+    }
+}
+
+Surface::Surface(wl_client *client, uint32_t id, int v, Compositor *compositor)
+    : QtWaylandServer::wl_surface(client, id, v)
+    , m_compositor(compositor)
+    , m_mockSurface(new MockSurface(this))
+{
+}
+
+Surface::~Surface()
+{
+    m_mockSurface->m_surface = 0;
+}
+
+void Surface::map()
+{
+    m_mapped = true;
+}
+
+bool Surface::isMapped() const
+{
+    return m_mapped;
+}
+
+Surface *Surface::fromResource(struct ::wl_resource *resource)
+{
+    if (auto *r = Resource::fromResource(resource))
+        return static_cast<Surface *>(r->surface_object);
+    return nullptr;
+}
+
+void Surface::surface_destroy_resource(Resource *)
+{
+    compositor()->removeSurface(this);
+    delete this;
+}
+
+void Surface::surface_destroy(Resource *resource)
+{
+    if (m_wlShellSurface) // on wl-shell the shell surface is automatically destroyed with the surface
+        wl_resource_destroy(m_wlShellSurface->resource()->handle);
+    Q_ASSERT(!m_wlShellSurface);
+    Q_ASSERT(!m_xdgSurfaceV6);
+    wl_resource_destroy(resource->handle);
+}
+
+void Surface::surface_attach(Resource *resource, struct wl_resource *buffer, int x, int y)
+{
+    if (m_xdgSurfaceV6) {
+        // It's a protocol error to attach a buffer to an xdgSurface that's not configured
+        Q_ASSERT(xdgSurfaceV6()->configureSent());
+    }
+
+    Q_UNUSED(resource);
+    Q_UNUSED(x);
+    Q_UNUSED(y);
+    m_buffer = buffer;
+
+    if (!buffer)
+        m_mockSurface->image = QImage();
+}
+
+void Surface::surface_damage(Resource *resource,
+                             int32_t x, int32_t y, int32_t width, int32_t height)
+{
+    Q_UNUSED(resource);
+    Q_UNUSED(x);
+    Q_UNUSED(y);
+    Q_UNUSED(width);
+    Q_UNUSED(height);
+}
+
+void Surface::surface_frame(Resource *resource,
+                            uint32_t callback)
+{
+    wl_resource *frameCallback = wl_resource_create(resource->client(), &wl_callback_interface, 1, callback);
+    m_frameCallbackList << frameCallback;
+}
+
+void Surface::surface_commit(Resource *resource)
+{
+    Q_UNUSED(resource);
+
+    if (m_buffer) {
+        struct ::wl_shm_buffer *shm_buffer = wl_shm_buffer_get(m_buffer);
+        if (shm_buffer) {
+            int stride = wl_shm_buffer_get_stride(shm_buffer);
+            uint format = wl_shm_buffer_get_format(shm_buffer);
+            Q_UNUSED(format);
+            void *data = wl_shm_buffer_get_data(shm_buffer);
+            const uchar *char_data = static_cast<const uchar *>(data);
+            QImage img(char_data, wl_shm_buffer_get_width(shm_buffer), wl_shm_buffer_get_height(shm_buffer), stride, QImage::Format_ARGB32_Premultiplied);
+            m_mockSurface->image = img;
+        }
+    }
+
+    foreach (wl_resource *frameCallback, m_frameCallbackList) {
+        wl_callback_send_done(frameCallback, m_compositor->time());
+        wl_resource_destroy(frameCallback);
+    }
+    m_frameCallbackList.clear();
+}
+
+}
+MockSurface::MockSurface(Impl::Surface *surface)
+    : m_surface(surface)
+{
+}
diff --git a/tests/auto/client/shared_old/mocksurface.h b/tests/auto/client/shared_old/mocksurface.h
new file mode 100644
index 000000000..949dc23dd
--- /dev/null
+++ b/tests/auto/client/shared_old/mocksurface.h
@@ -0,0 +1,87 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef MOCKSURFACE_H
+#define MOCKSURFACE_H
+
+#include <qglobal.h>
+
+#include "qwayland-server-wayland.h"
+
+#include "mockcompositor.h"
+
+namespace Impl {
+
+class XdgToplevelV6;
+class WlShellSurface;
+
+class Surface : public QtWaylandServer::wl_surface
+{
+public:
+    Surface(wl_client *client, uint32_t id, int v, Compositor *compositor);
+    ~Surface();
+
+    Compositor *compositor() const { return m_compositor; }
+    static Surface *fromResource(struct ::wl_resource *resource);
+    void map();
+    bool isMapped() const;
+    XdgSurfaceV6 *xdgSurfaceV6() const { return m_xdgSurfaceV6; }
+    XdgToplevelV6 *xdgToplevelV6() const { return m_xdgSurfaceV6 ? m_xdgSurfaceV6->toplevel() : nullptr; }
+    WlShellSurface *wlShellSurface() const { return m_wlShellSurface; }
+
+    QSharedPointer<MockSurface> mockSurface() const { return m_mockSurface; }
+
+protected:
+
+    void surface_destroy_resource(Resource *resource) override;
+
+    void surface_destroy(Resource *resource) override;
+    void surface_attach(Resource *resource,
+                        struct wl_resource *buffer, int x, int y) override;
+    void surface_damage(Resource *resource,
+                        int32_t x, int32_t y, int32_t width, int32_t height) override;
+    void surface_frame(Resource *resource,
+                       uint32_t callback) override;
+    void surface_commit(Resource *resource) override;
+private:
+    wl_resource *m_buffer = nullptr;
+    XdgSurfaceV6 *m_xdgSurfaceV6 = nullptr;
+    WlShellSurface *m_wlShellSurface = nullptr;
+
+    Compositor *m_compositor = nullptr;
+    QSharedPointer<MockSurface> m_mockSurface;
+    QList<wl_resource *> m_frameCallbackList;
+    bool m_mapped = false;
+
+    friend class XdgSurfaceV6;
+    friend class WlShellSurface;
+};
+
+}
+
+#endif // MOCKSURFACE_H
diff --git a/tests/auto/client/shared_old/mockwlshell.cpp b/tests/auto/client/shared_old/mockwlshell.cpp
new file mode 100644
index 000000000..50e539932
--- /dev/null
+++ b/tests/auto/client/shared_old/mockwlshell.cpp
@@ -0,0 +1,52 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mockwlshell.h"
+#include "mocksurface.h"
+
+namespace Impl {
+
+WlShellSurface::WlShellSurface(wl_client *client, int id, Surface *surface)
+    : QtWaylandServer::wl_shell_surface(client, id, 1)
+    , m_surface(surface)
+{
+    surface->m_wlShellSurface = this;
+    surface->map();
+}
+
+WlShellSurface::~WlShellSurface()
+{
+    m_surface->m_wlShellSurface = nullptr;
+}
+
+void WlShell::shell_get_shell_surface(QtWaylandServer::wl_shell::Resource *resource, uint32_t id, wl_resource *surface)
+{
+    new WlShellSurface(resource->client(), id, Surface::fromResource(surface));
+}
+
+} // namespace Impl
diff --git a/tests/auto/client/shared_old/mockwlshell.h b/tests/auto/client/shared_old/mockwlshell.h
new file mode 100644
index 000000000..3da586ca8
--- /dev/null
+++ b/tests/auto/client/shared_old/mockwlshell.h
@@ -0,0 +1,58 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qwayland-server-wayland.h>
+
+#ifndef MOCKWLSHELL_H
+#define MOCKWLSHELL_H
+
+namespace Impl {
+
+class Surface;
+
+class WlShellSurface : public QtWaylandServer::wl_shell_surface
+{
+public:
+    explicit WlShellSurface(::wl_client *client, int id, Surface *surface);
+    ~WlShellSurface() override;
+    void shell_surface_destroy_resource(Resource *) override { delete this; }
+
+private:
+    Surface *m_surface = nullptr;
+};
+
+class WlShell : public QtWaylandServer::wl_shell
+{
+public:
+    explicit WlShell(::wl_display *display) : wl_shell(display, 1) {}
+    void shell_get_shell_surface(Resource *resource, uint32_t id, ::wl_resource *surface) override;
+};
+
+} // namespace Impl
+
+#endif // MOCKWLSHELL_H
diff --git a/tests/auto/client/shared_old/mockxdgshellv6.cpp b/tests/auto/client/shared_old/mockxdgshellv6.cpp
new file mode 100644
index 000000000..05eff74ad
--- /dev/null
+++ b/tests/auto/client/shared_old/mockxdgshellv6.cpp
@@ -0,0 +1,145 @@
+/****************************************************************************
+**
+** Copyright (C) 2017 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "mockxdgshellv6.h"
+#include "mocksurface.h"
+#include "mockcompositor.h"
+
+namespace Impl {
+
+void Compositor::sendXdgToplevelV6Configure(void *data, const QList<QVariant> &parameters)
+{
+    Compositor *compositor = static_cast<Compositor *>(data);
+    XdgToplevelV6 *toplevel = resolveToplevel(parameters.at(0));
+    Q_ASSERT(toplevel && toplevel->resource());
+    QSize size = parameters.at(1).toSize();
+    Q_ASSERT(size.isValid());
+    auto statesBytes = parameters.at(2).toByteArray();
+    toplevel->send_configure(size.width(), size.height(), statesBytes);
+    toplevel->xdgSurface()->send_configure(compositor->nextSerial());
+}
+
+XdgSurfaceV6::XdgSurfaceV6(XdgShellV6 *shell, Surface *surface, wl_client *client, uint32_t id)
+    : QtWaylandServer::zxdg_surface_v6(client, id, 1)
+    , m_surface(surface)
+    , m_shell(shell)
+{
+    m_surface->m_xdgSurfaceV6 = this;
+}
+
+XdgSurfaceV6::~XdgSurfaceV6()
+{
+    m_surface->m_xdgSurfaceV6 = nullptr;
+}
+
+void XdgSurfaceV6::sendConfigure(uint32_t serial)
+{
+    send_configure(serial);
+    m_configureSent = true;
+}
+
+void XdgSurfaceV6::zxdg_surface_v6_get_toplevel(QtWaylandServer::zxdg_surface_v6::Resource *resource, uint32_t id)
+{
+    int version = wl_resource_get_version(resource->handle);
+    m_toplevel = new XdgToplevelV6(this, resource->client(), id, version);
+}
+
+void XdgSurfaceV6::zxdg_surface_v6_set_window_geometry(QtWaylandServer::zxdg_surface_v6::Resource *resource, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+    Q_UNUSED(resource);
+    if (m_toplevel) {
+        QRect geometry(x, y, width, height);
+        emit m_toplevel->mockToplevel()->windowGeometryRequested(geometry);
+    }
+}
+
+void XdgSurfaceV6::zxdg_surface_v6_destroy(QtWaylandServer::zxdg_surface_v6::Resource *resource)
+{
+    Q_ASSERT(!m_toplevel);
+    wl_resource_destroy(resource->handle);
+}
+
+XdgToplevelV6::XdgToplevelV6(XdgSurfaceV6 *xdgSurface, wl_client *client, uint32_t id, int version)
+    : QtWaylandServer::zxdg_toplevel_v6(client, id, version)
+    , m_xdgSurface(xdgSurface)
+    , m_mockToplevel(new MockXdgToplevelV6(this))
+{
+    auto *surface = m_xdgSurface->surface();
+    m_xdgSurface->shell()->addToplevel(this);
+    surface->map();
+}
+
+XdgToplevelV6::~XdgToplevelV6()
+{
+    m_xdgSurface->shell()->removeToplevel(this);
+    m_mockToplevel->m_toplevel = nullptr;
+}
+
+void XdgToplevelV6::zxdg_toplevel_v6_destroy(QtWaylandServer::zxdg_toplevel_v6::Resource *resource)
+{
+    m_xdgSurface->m_toplevel = nullptr;
+    wl_resource_destroy(resource->handle);
+}
+
+void XdgToplevelV6::zxdg_toplevel_v6_set_minimized(QtWaylandServer::zxdg_toplevel_v6::Resource *resource)
+{
+    Q_UNUSED(resource);
+    emit m_mockToplevel->setMinimizedRequested();
+}
+
+void XdgToplevelV6::zxdg_toplevel_v6_set_maximized(QtWaylandServer::zxdg_toplevel_v6::Resource *resource)
+{
+    Q_UNUSED(resource);
+    emit m_mockToplevel->setMaximizedRequested();
+}
+
+void XdgToplevelV6::zxdg_toplevel_v6_unset_maximized(QtWaylandServer::zxdg_toplevel_v6::Resource *resource)
+{
+    Q_UNUSED(resource);
+    emit m_mockToplevel->unsetMaximizedRequested();
+}
+
+void XdgToplevelV6::zxdg_toplevel_v6_set_fullscreen(QtWaylandServer::zxdg_toplevel_v6::Resource *resource, wl_resource *output)
+{
+    Q_UNUSED(resource);
+    Q_UNUSED(output);
+    emit m_mockToplevel->setFullscreenRequested();
+}
+
+void XdgToplevelV6::zxdg_toplevel_v6_unset_fullscreen(QtWaylandServer::zxdg_toplevel_v6::Resource *resource)
+{
+    Q_UNUSED(resource);
+    emit m_mockToplevel->unsetFullscreenRequested();
+}
+
+void Impl::XdgShellV6::zxdg_shell_v6_get_xdg_surface(QtWaylandServer::zxdg_shell_v6::Resource *resource, uint32_t id, wl_resource *surface)
+{
+    new XdgSurfaceV6(this, Surface::fromResource(surface), resource->client(), id);
+}
+
+} // namespace Impl
diff --git a/tests/auto/client/shared_old/mockxdgshellv6.h b/tests/auto/client/shared_old/mockxdgshellv6.h
new file mode 100644
index 000000000..a238fa562
--- /dev/null
+++ b/tests/auto/client/shared_old/mockxdgshellv6.h
@@ -0,0 +1,114 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:GPL-EXCEPT$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <qwayland-server-xdg-shell-unstable-v6.h>
+
+#include <QSharedPointer>
+#include <QVector>
+
+#ifndef MOCKXDGSHELLV6_H
+#define MOCKXDGSHELLV6_H
+
+class MockXdgToplevelV6;
+
+namespace Impl {
+
+class XdgToplevelV6;
+class XdgShellV6;
+class Surface;
+
+class XdgSurfaceV6 : public QtWaylandServer::zxdg_surface_v6
+{
+public:
+    XdgSurfaceV6(XdgShellV6 *shell, Surface *surface, wl_client *client, uint32_t id);
+    ~XdgSurfaceV6() override;
+    XdgShellV6 *shell() const { return m_shell; }
+    Surface *surface() const { return m_surface; }
+    XdgToplevelV6 *toplevel() const { return m_toplevel; }
+
+    void sendConfigure(uint32_t serial);
+    bool configureSent() const { return m_configureSent; }
+
+protected:
+    void zxdg_surface_v6_destroy_resource(Resource *) override { delete this; }
+    void zxdg_surface_v6_get_toplevel(Resource *resource, uint32_t id) override;
+    void zxdg_surface_v6_set_window_geometry(Resource *resource, int32_t x, int32_t y, int32_t width, int32_t height) override;
+    void zxdg_surface_v6_destroy(Resource *resource) override;
+
+private:
+    Surface *m_surface = nullptr;
+    XdgToplevelV6 *m_toplevel = nullptr;
+    XdgShellV6 *m_shell = nullptr;
+    bool m_configureSent = false;
+
+    friend class XdgToplevelV6;
+};
+
+class XdgToplevelV6 : public QtWaylandServer::zxdg_toplevel_v6
+{
+public:
+    XdgToplevelV6(XdgSurfaceV6 *xdgSurface, wl_client *client, uint32_t id, int version);
+    ~XdgToplevelV6() override;
+    XdgSurfaceV6 *xdgSurface() const { return m_xdgSurface; }
+
+    QSharedPointer<MockXdgToplevelV6> mockToplevel() const { return m_mockToplevel; }
+
+protected:
+    void zxdg_toplevel_v6_destroy_resource(Resource *) override { delete this; }
+    void zxdg_toplevel_v6_destroy(Resource *resource) override;
+    void zxdg_toplevel_v6_set_minimized(Resource *resource) override;
+    void zxdg_toplevel_v6_set_maximized(Resource *resource) override;
+    void zxdg_toplevel_v6_unset_maximized(Resource *resource) override;
+    void zxdg_toplevel_v6_set_fullscreen(Resource *resource, struct ::wl_resource *output) override;
+    void zxdg_toplevel_v6_unset_fullscreen(Resource *resource) override;
+
+private:
+    XdgSurfaceV6 *m_xdgSurface = nullptr;
+    QSharedPointer<MockXdgToplevelV6> m_mockToplevel;
+};
+
+class XdgShellV6 : public QtWaylandServer::zxdg_shell_v6
+{
+public:
+    explicit XdgShellV6(::wl_display *display) : zxdg_shell_v6(display, 1) {}
+    QVector<XdgToplevelV6 *> toplevels() const { return m_toplevels; }
+
+protected:
+    void zxdg_shell_v6_get_xdg_surface(Resource *resource, uint32_t id, ::wl_resource *surface) override;
+
+private:
+    void addToplevel(XdgToplevelV6 *toplevel) { m_toplevels.append(toplevel); }
+    void removeToplevel(XdgToplevelV6 *toplevel) { m_toplevels.removeOne(toplevel); }
+    QVector<XdgToplevelV6 *> m_toplevels;
+
+    friend class XdgToplevelV6;
+};
+
+} // namespace Impl
+
+#endif // MOCKXDGSHELLV6_H
diff --git a/tests/auto/client/shared_old/shared_old.pri b/tests/auto/client/shared_old/shared_old.pri
new file mode 100644
index 000000000..467e98115
--- /dev/null
+++ b/tests/auto/client/shared_old/shared_old.pri
@@ -0,0 +1,34 @@
+CONFIG += testcase link_pkgconfig
+QT += testlib
+QT += core-private gui-private waylandclient-private
+
+QMAKE_USE += wayland-client wayland-server
+
+CONFIG += wayland-scanner
+WAYLANDSERVERSOURCES += \
+    ../../../../src/3rdparty/protocol/ivi-application.xml \
+    ../../../../src/3rdparty/protocol/wayland.xml \
+    ../../../../src/3rdparty/protocol/xdg-shell-unstable-v6.xml \
+    ../../../../src/3rdparty/protocol/fullscreen-shell-unstable-v1.xml
+
+INCLUDEPATH += ../shared_old
+
+SOURCES += \
+    ../shared_old/mockcompositor.cpp \
+    ../shared_old/mockfullscreenshellv1.cpp \
+    ../shared_old/mockinput.cpp \
+    ../shared_old/mockiviapplication.cpp \
+    ../shared_old/mockwlshell.cpp \
+    ../shared_old/mockxdgshellv6.cpp \
+    ../shared_old/mocksurface.cpp \
+    ../shared_old/mockoutput.cpp
+
+HEADERS += \
+    ../shared_old/mockcompositor.h \
+    ../shared_old/mockfullscreenshellv1.h \
+    ../shared_old/mockinput.h \
+    ../shared_old/mockiviapplication.h \
+    ../shared_old/mockwlshell.h \
+    ../shared_old/mockxdgshellv6.h \
+    ../shared_old/mocksurface.h \
+    ../shared_old/mockoutput.h