diff --git a/README.md b/README.md
index da6e3b89bebe07a7af7dce9d44b8b99e7941b7d9..a77d693b7ef9a22623e6d2463e147d9fbb8b5848 100644
--- a/README.md
+++ b/README.md
@@ -3,8 +3,6 @@ This is a test suite for X.Org tests.
 == Building the code ==
 
 ```
-$ git submodule init
-$ git submodule update
 $ meson builddir
 $ ninja -C builddir
 ```
diff --git a/gtest/include/xorg/gtest/inputtest/xorg-gtest-device.h b/gtest/include/xorg/gtest/inputtest/xorg-gtest-device.h
new file mode 100644
index 0000000000000000000000000000000000000000..4c959c2da4a174a809d084ed3cfe2304eeb58354
--- /dev/null
+++ b/gtest/include/xorg/gtest/inputtest/xorg-gtest-device.h
@@ -0,0 +1,111 @@
+/*******************************************************************************
+ *
+ * X testing environment - Google Test environment feat. dummy x server
+ *
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ ******************************************************************************/
+
+#ifndef XORG_INPUTTEST_DEVICE_H_
+#define XORG_INPUTTEST_DEVICE_H_
+
+#include <memory>
+#include <string>
+#include "xorg-gtest-valuators.h"
+
+namespace xorg {
+namespace testing {
+namespace inputtest {
+
+enum class DeviceType {
+    KEYBOARD,
+    POINTER,
+    POINTER_ABSOLUTE,
+    POINTER_ABSOLUTE_PROXIMITY,
+    TOUCH
+};
+
+#define XORG_INPUTTEST_DRIVER "inputtest"
+
+/**
+ * A device to replay events through the xf86-input-inputtest input driver
+ */
+class Device {
+public:
+    /**
+     * Create a new device context.
+     *
+     * @param [in] socket_path Path where the UNIX domain socket used for communication with the
+     *             driver will be constructed.
+     * @param [in] type The type of the device which defines what operations are available.
+     */
+    explicit Device(const std::string& socket_path, DeviceType type);
+    ~Device();
+
+    /**
+     * Returns the options that the server needs to be configured for this device.
+     */
+    std::string GetOptions() const;
+
+    /**
+     * Waits for the connection to the driver being established.
+     * Throws an exception if the files are not available after 10 seconds.
+     */
+    void WaitForDriver();
+
+    /**
+     * All of the functions below result in an input event being sent to the X server.
+     * WaitForDriver() must be called before using them.
+     */
+    void RelMotion(double x, double y);
+    void RelMotion(double x, double y, const Valuators& extra_valuators);
+
+    void AbsMotion(double x, double y);
+    void AbsMotion(double x, double y, const Valuators& extra_valuators);
+
+    void ProximityIn(const Valuators& valuators);
+    void ProximityOut(const Valuators& valuators);
+
+    void ButtonDown(std::int32_t button);
+    void ButtonUp(std::int32_t button);
+
+    void KeyDown(std::int32_t key_code);
+    void KeyUp(std::int32_t key_code);
+
+    void TouchBegin(double x, double y, std::uint32_t id);
+    void TouchBegin(double x, double y, std::uint32_t id, const Valuators& extra_valuators);
+    void TouchUpdate(double x, double y, std::uint32_t id);
+    void TouchUpdate(double x, double y, std::uint32_t id, const Valuators& extra_valuators);
+    void TouchEnd(double x, double y, std::uint32_t id);
+    void TouchEnd(double x, double y, std::uint32_t id, const Valuators& extra_valuators);
+
+private:
+
+    struct Private;
+    std::unique_ptr<Private> d_;
+};
+
+} // namespace inputtest
+} // namespace testing
+} // namespace xorg
+
+#endif // XORG_INPUTTEST_DEVICE_H_
diff --git a/gtest/include/xorg/gtest/inputtest/xorg-gtest-valuators.h b/gtest/include/xorg/gtest/inputtest/xorg-gtest-valuators.h
new file mode 100644
index 0000000000000000000000000000000000000000..b844bd0f43ad4844be84d256a199488dafe86004
--- /dev/null
+++ b/gtest/include/xorg/gtest/inputtest/xorg-gtest-valuators.h
@@ -0,0 +1,67 @@
+/*******************************************************************************
+ *
+ * X testing environment - Google Test environment feat. dummy x server
+ *
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ ******************************************************************************/
+
+#ifndef XORG_INPUTTEST_VALUATORS_H_
+#define XORG_INPUTTEST_VALUATORS_H_
+
+#include <memory>
+#include <string>
+
+#include <xf86-input-inputtest-protocol.h>
+
+namespace xorg {
+namespace testing {
+namespace inputtest {
+
+/**
+ * A class that represents the valuator values sent to the X server.
+ * The axes are hardcoded according to the current implementation of the xf86-input-inputtest
+ * input driver.
+ */
+
+class Valuators {
+public:
+    Valuators();
+    Valuators(const Valuators& other);
+    Valuators& operator=(const Valuators& other);
+    ~Valuators();
+
+    Valuators& Set(unsigned axis, double value);
+    Valuators& SetUnaccel(unsigned axis, double value_accel, double value_unaccel);
+
+    void RetrieveValuatorData(xf86ITValuatorData* out) const;
+
+private:
+    struct Private;
+    std::unique_ptr<Private> d_;
+};
+
+} // namespace inputtest
+} // namespace testing
+} // namespace xorg
+
+#endif // XORG_INPUTTEST_VALUATORS_H_
diff --git a/gtest/include/xorg/gtest/xorg-gtest.h b/gtest/include/xorg/gtest/xorg-gtest.h
index 47525e6ca8c297f2d8899bbaa5096ff64a8b2c81..68359c7841318c229cecae6cb78a7badecc11b16 100644
--- a/gtest/include/xorg/gtest/xorg-gtest.h
+++ b/gtest/include/xorg/gtest/xorg-gtest.h
@@ -34,6 +34,9 @@
 #include "xorg-gtest-test.h"
 #include "evemu/xorg-gtest-device.h"
 
+#include "inputtest/xorg-gtest-device.h"
+#include "inputtest/xorg-gtest-valuators.h"
+
 #define XORG_TESTCASE(message) \
   SCOPED_TRACE("\n::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::\n" \
                "TESTCASE:\n" \
diff --git a/gtest/src/inputtest-device.cpp b/gtest/src/inputtest-device.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b66b0729d2f889c1f35281b8d979ae16293b0921
--- /dev/null
+++ b/gtest/src/inputtest-device.cpp
@@ -0,0 +1,251 @@
+/*******************************************************************************
+ *
+ * X testing environment - Google Test environment feat. dummy x server
+ *
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ ******************************************************************************/
+
+#include "xorg/gtest/inputtest/xorg-gtest-device.h"
+#include "inputtest-driver-connection.h"
+
+#include <X11/extensions/XInput2.h>
+
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <cstring>
+#include <stdexcept>
+#include <thread>
+
+namespace xorg {
+namespace testing {
+namespace inputtest {
+
+namespace {
+
+std::string DeviceTypeToOptionString(DeviceType type)
+{
+    switch (type) {
+        case DeviceType::KEYBOARD: return "Keyboard";
+        case DeviceType::POINTER: return "Pointer";
+        case DeviceType::POINTER_ABSOLUTE: return "PointerAbsolute";
+        case DeviceType::POINTER_ABSOLUTE_PROXIMITY: return "PointerAbsoluteProximity";
+        case DeviceType::TOUCH: return "Touch";
+    }
+    return "";
+}
+
+void EnsureDeviceTypeForEvent(DeviceType type, std::initializer_list<DeviceType> allowed_types)
+{
+    for (auto allowed_type : allowed_types) {
+    if (type == allowed_type)
+        return;
+    }
+    throw std::runtime_error("Unsupported event for the device type");
+}
+
+} // namespace
+
+struct Device::Private {
+    Private(const std::string& socket_path) :
+        connection(socket_path) {}
+
+    DriverConnection connection;
+    DeviceType device_type;
+};
+
+Device::Device(const std::string& socket_path, DeviceType type) :
+    d_{std::unique_ptr<Private>(new Private(socket_path))}
+{
+    d_->device_type = type;
+}
+
+Device::~Device()
+{
+}
+
+std::string Device::GetOptions() const
+{
+    // add a new line before to protect against accidentally missed newline in the rest of
+    // configuration
+    return "\n"
+        "Option \"DeviceType\" \"" + DeviceTypeToOptionString(d_->device_type) + "\"\n"
+        "Option \"SocketPath\" \"" + d_->connection.SocketPath() + "\"\n";
+}
+
+void Device::WaitForDriver()
+{
+    d_->connection.WaitForDriver();
+}
+
+void Device::RelMotion(double x, double y)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::POINTER});
+    Valuators valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.RelMotion(valuators);
+}
+
+void Device::RelMotion(double x, double y, const Valuators& extra_valuators)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::POINTER});
+    Valuators valuators = extra_valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.RelMotion(valuators);
+}
+
+void Device::AbsMotion(double x, double y)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::POINTER_ABSOLUTE});
+    Valuators valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.AbsMotion(valuators);
+}
+
+void Device::AbsMotion(double x, double y, const Valuators& extra_valuators)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::POINTER_ABSOLUTE});
+    Valuators valuators = extra_valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.AbsMotion(valuators);
+}
+
+void Device::ProximityIn(const Valuators& valuators)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::POINTER_ABSOLUTE_PROXIMITY});
+    d_->connection.ProximityIn(valuators);
+}
+
+void Device::ProximityOut(const Valuators& valuators)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::POINTER_ABSOLUTE_PROXIMITY});
+    d_->connection.ProximityOut(valuators);
+}
+
+void Device::ButtonDown(std::int32_t button)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {
+        DeviceType::POINTER,
+        DeviceType::POINTER_ABSOLUTE,
+        DeviceType::POINTER_ABSOLUTE_PROXIMITY,
+    });
+    if (button == 0 || button >= 256)
+        throw std::runtime_error("Invalid button number");
+
+    if (d_->device_type == DeviceType::POINTER) {
+        d_->connection.ButtonDownRel(button, Valuators());
+    } else {
+        d_->connection.ButtonDownAbs(button, Valuators());
+    }
+}
+
+void Device::ButtonUp(std::int32_t button)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {
+        DeviceType::POINTER,
+        DeviceType::POINTER_ABSOLUTE,
+        DeviceType::POINTER_ABSOLUTE_PROXIMITY,
+    });
+    if (button == 0 || button >= 256)
+        throw std::runtime_error("Invalid button number");
+
+    if (d_->device_type == DeviceType::POINTER) {
+        d_->connection.ButtonUpRel(button, Valuators());
+    } else {
+        d_->connection.ButtonUpAbs(button, Valuators());
+    }
+}
+
+void Device::KeyDown(std::int32_t key_code)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::KEYBOARD});
+    d_->connection.KeyDown(key_code);
+}
+
+void Device::KeyUp(std::int32_t key_code)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::KEYBOARD});
+    d_->connection.KeyUp(key_code);
+}
+
+void Device::TouchBegin(double x, double y, std::uint32_t id)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::TOUCH});
+    Valuators valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.TouchBegin(id, valuators);
+}
+
+void Device::TouchBegin(double x, double y, std::uint32_t id, const Valuators& extra_valuators)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::TOUCH});
+    Valuators valuators = extra_valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.TouchBegin(id, valuators);
+}
+
+void Device::TouchUpdate(double x, double y, std::uint32_t id)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::TOUCH});
+    Valuators valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.TouchUpdate(id, valuators);
+}
+
+void Device::TouchUpdate(double x, double y, std::uint32_t id, const Valuators& extra_valuators)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::TOUCH});
+    Valuators valuators = extra_valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.TouchUpdate(id, valuators);
+}
+
+void Device::TouchEnd(double x, double y, std::uint32_t id)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::TOUCH});
+    Valuators valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.TouchEnd(id, valuators);
+}
+
+void Device::TouchEnd(double x, double y, std::uint32_t id, const Valuators& extra_valuators)
+{
+    EnsureDeviceTypeForEvent(d_->device_type, {DeviceType::TOUCH});
+    Valuators valuators = extra_valuators;
+    valuators.Set(0, x);
+    valuators.Set(1, y);
+    d_->connection.TouchEnd(id, valuators);
+}
+
+} // namespace xorg
+} // namespace testing
+} // namespace inputtest
diff --git a/gtest/src/inputtest-driver-connection.cpp b/gtest/src/inputtest-driver-connection.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..564d100697764c6b9ced165ac4ad002f752e2311
--- /dev/null
+++ b/gtest/src/inputtest-driver-connection.cpp
@@ -0,0 +1,320 @@
+/*******************************************************************************
+ *
+ * X testing environment - Google Test environment feat. dummy x server
+ *
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ ******************************************************************************/
+
+#include "inputtest-driver-connection.h"
+
+#include <X11/extensions/XInput2.h>
+#include <xf86-input-inputtest-protocol.h>
+
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <cstring>
+#include <string>
+#include <stdexcept>
+#include <thread>
+
+namespace xorg {
+namespace testing {
+namespace inputtest {
+
+namespace {
+
+constexpr std::int32_t XORG_KEY_CODE_OFFSET = 8;
+
+template<class T>
+void SendEvent(int fd, const T& ev)
+{
+    if (write(fd, &ev, ev.header.length) != ev.header.length)
+        throw std::runtime_error("Failed to send event");
+}
+
+template<class T>
+T CreateEvent(xf86ITEventType type)
+{
+    T event;
+    std::memset(&event, 0, sizeof(event));
+    event.header.length = sizeof(event);
+    event.header.type = type;
+    return event;
+}
+
+void SendButtonEvent(int fd, bool is_press, bool is_absolute, std::int32_t button,
+                     const Valuators& valuators)
+{
+    xf86ITEventButton ev = CreateEvent<xf86ITEventButton>(XF86IT_EVENT_BUTTON);
+    ev.is_absolute = is_absolute;
+    ev.button = button;
+    ev.is_press = is_press;
+    valuators.RetrieveValuatorData(&ev.valuators);
+    SendEvent(fd, ev);
+}
+
+void SendTouchEvent(int fd, std::uint16_t type, std::uint32_t touchid, const Valuators& valuators)
+{
+    xf86ITEventTouch ev = CreateEvent<xf86ITEventTouch>(XF86IT_EVENT_TOUCH);
+    ev.touch_type = type;
+    ev.touchid = touchid;
+    valuators.RetrieveValuatorData(&ev.valuators);
+    SendEvent(fd, ev);
+}
+
+template<class T>
+T ReceiveResponse(int fd, int type)
+{
+    T response;
+    std::memset(&response, 0, sizeof(response));
+    if (read(fd, &response, sizeof(response)) != sizeof(response))
+        throw std::runtime_error("Could not read event " + std::to_string(type));
+    if (response.header.type != type)
+        throw std::runtime_error("Invalid response type: got " + std::to_string(response.header.type) +
+                               " expected " + std::to_string(type));
+    if (response.header.length != sizeof(response))
+        throw std::runtime_error("Invalid response length");
+    return response;
+}
+
+} // namespace
+
+struct DriverConnection::Private {
+    std::string socket_path;
+    std::uint32_t protocol_version_major = 0;
+    std::uint32_t protocol_version_minor = 0;
+    int socket_fd = -1;
+};
+
+DriverConnection::DriverConnection(const std::string& socket_path) :
+    d_{std::unique_ptr<Private>(new Private)}
+{
+    d_->socket_path = socket_path;
+}
+
+DriverConnection::~DriverConnection()
+{
+    Close();
+}
+
+const std::string& DriverConnection::SocketPath() const
+{
+    return d_->socket_path;
+}
+
+bool DriverConnection::TryConnectToDriver()
+{
+    if (d_->socket_fd != -1) {
+        return true;
+    }
+
+    sockaddr_un address = {};
+
+    if (d_->socket_path.size() > sizeof(address.sun_path))
+        throw std::runtime_error("Too long path to connect to driver");
+
+    address.sun_family = AF_UNIX;
+    std::strncpy(address.sun_path, d_->socket_path.c_str(), sizeof(address.sun_path));
+
+    if (access(d_->socket_path.c_str(), F_OK) == -1) {
+        return false;
+    }
+    int socket_fd = socket(PF_UNIX, SOCK_STREAM, 0);
+    if (socket_fd < 0)
+        throw std::runtime_error("Can't create socket");
+
+    if (connect(socket_fd, reinterpret_cast<sockaddr*>(&address), sizeof(address)) != 0) {
+        close(socket_fd);
+        return false;
+    }
+
+    d_->socket_fd = socket_fd;
+    return true;
+}
+
+void DriverConnection::WaitForDriver()
+{
+    unsigned timeout_ms = 10000;
+    unsigned sleep_ms = 20;
+
+    if (d_->socket_fd != -1)
+        return;
+
+    for (unsigned i = 0; i < timeout_ms; i += sleep_ms) {
+        if (!TryConnectToDriver()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(sleep_ms));
+            continue;
+        }
+
+        xf86ITEventClientVersion ev = CreateEvent<xf86ITEventClientVersion>(XF86IT_EVENT_CLIENT_VERSION);
+        ev.major = XF86IT_PROTOCOL_VERSION_MAJOR;
+        ev.minor = XF86IT_PROTOCOL_VERSION_MINOR;
+        SendEvent(d_->socket_fd, ev);
+
+        xf86ITResponseServerVersion response =
+            ReceiveResponse<xf86ITResponseServerVersion>(d_->socket_fd, XF86IT_RESPONSE_SERVER_VERSION);
+
+        d_->protocol_version_major = response.major;
+        d_->protocol_version_minor = response.minor;
+        return;
+    }
+
+    throw std::runtime_error("Timed out waiting for device files to be opened");
+}
+
+void DriverConnection::Close()
+{
+    if (d_->socket_fd != -1) {
+        close(d_->socket_fd);
+        d_->socket_fd = -1;
+    }
+}
+
+void DriverConnection::Sync()
+{
+    xf86ITEventWaitForSync ev = CreateEvent<xf86ITEventWaitForSync>(XF86IT_EVENT_WAIT_FOR_SYNC);
+    SendEvent(d_->socket_fd, ev);
+    ReceiveResponse<xf86ITResponseSyncFinished>(d_->socket_fd, XF86IT_RESPONSE_SYNC_FINISHED);
+}
+
+void DriverConnection::EnsureConnectedToDriver()
+{
+    if (d_->socket_fd == -1)
+        throw std::runtime_error("DriverConnection is not open");
+}
+
+void DriverConnection::RelMotion(const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    xf86ITEventMotion ev = CreateEvent<xf86ITEventMotion>(XF86IT_EVENT_MOTION);
+    ev.is_absolute = false;
+    valuators.RetrieveValuatorData(&ev.valuators);
+    SendEvent(d_->socket_fd, ev);
+    Sync();
+}
+
+void DriverConnection::AbsMotion(const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    xf86ITEventMotion ev = CreateEvent<xf86ITEventMotion>(XF86IT_EVENT_MOTION);
+    ev.is_absolute = true;
+    valuators.RetrieveValuatorData(&ev.valuators);
+    SendEvent(d_->socket_fd, ev);
+    Sync();
+}
+
+void DriverConnection::ProximityIn(const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    xf86ITEventProximity ev = CreateEvent<xf86ITEventProximity>(XF86IT_EVENT_PROXIMITY);
+    ev.is_prox_in = true;
+    valuators.RetrieveValuatorData(&ev.valuators);
+    SendEvent(d_->socket_fd, ev);
+    Sync();
+}
+
+void DriverConnection::ProximityOut(const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    xf86ITEventProximity ev = CreateEvent<xf86ITEventProximity>(XF86IT_EVENT_PROXIMITY);
+    ev.is_prox_in = false;
+    valuators.RetrieveValuatorData(&ev.valuators);
+    SendEvent(d_->socket_fd, ev);
+    Sync();
+}
+
+void DriverConnection::ButtonDownAbs(std::int32_t button, const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    SendButtonEvent(d_->socket_fd, true, true, button, valuators);
+    Sync();
+}
+
+void DriverConnection::ButtonDownRel(std::int32_t button, const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    SendButtonEvent(d_->socket_fd, true, false, button, valuators);
+    Sync();
+}
+
+void DriverConnection::ButtonUpAbs(std::int32_t button, const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    SendButtonEvent(d_->socket_fd, false, true, button, valuators);
+    Sync();
+}
+
+void DriverConnection::ButtonUpRel(std::int32_t button, const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    SendButtonEvent(d_->socket_fd, false, false, button, valuators);
+    Sync();
+}
+
+void DriverConnection::KeyDown(std::int32_t key_code)
+{
+    EnsureConnectedToDriver();
+    xf86ITEventKey ev = CreateEvent<xf86ITEventKey>(XF86IT_EVENT_KEY);
+    ev.is_press = true;
+    ev.key_code = key_code + XORG_KEY_CODE_OFFSET;
+    SendEvent(d_->socket_fd, ev);
+    Sync();
+}
+
+void DriverConnection::KeyUp(std::int32_t key_code)
+{
+    EnsureConnectedToDriver();
+    xf86ITEventKey ev = CreateEvent<xf86ITEventKey>(XF86IT_EVENT_KEY);
+    ev.is_press = false;
+    ev.key_code = key_code + XORG_KEY_CODE_OFFSET;
+    SendEvent(d_->socket_fd, ev);
+    Sync();
+}
+
+void DriverConnection::TouchBegin(std::uint32_t id, const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    SendTouchEvent(d_->socket_fd, XI_TouchBegin, id, valuators);
+    Sync();
+}
+
+void DriverConnection::TouchUpdate(std::uint32_t id, const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    SendTouchEvent(d_->socket_fd, XI_TouchUpdate, id, valuators);
+    Sync();
+}
+
+void DriverConnection::TouchEnd(std::uint32_t id, const Valuators& valuators)
+{
+    EnsureConnectedToDriver();
+    SendTouchEvent(d_->socket_fd, XI_TouchEnd, id, valuators);
+    Sync();
+}
+
+} // namespace xorg
+} // namespace testing
+} // namespace inputtest
diff --git a/gtest/src/inputtest-driver-connection.h b/gtest/src/inputtest-driver-connection.h
new file mode 100644
index 0000000000000000000000000000000000000000..af17cac5e9c7d6d2575fba90b5d940db649468fb
--- /dev/null
+++ b/gtest/src/inputtest-driver-connection.h
@@ -0,0 +1,112 @@
+/*******************************************************************************
+ *
+ * X testing environment - Google Test environment feat. dummy x server
+ *
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ ******************************************************************************/
+
+#ifndef XORG_INPUTTEST_DRIVER_CONNECTION_H_
+#define XORG_INPUTTEST_DRIVER_CONNECTION_H_
+
+#include <memory>
+#include <string>
+#include "xorg/gtest/inputtest/xorg-gtest-valuators.h"
+
+namespace xorg {
+namespace testing {
+namespace inputtest {
+
+/**
+ * A connection to replay events through the xf86-input-inputtest input driver
+ */
+
+class DriverConnection {
+public:
+    /**
+     * Create a new driver connection.
+     *
+     * @param [in] socket_path Path to the domain socket that will be used to communicate with the
+     *             driver
+    */
+    explicit DriverConnection(const std::string& socket_path);
+    ~DriverConnection();
+
+    /**
+     * Returns the events input path
+    */
+    const std::string& SocketPath() const;
+
+    /**
+     * Waits for the connection to the driver being established.
+     * Throws an exception if this can not be achieved within 10 seconds.
+    */
+    void WaitForDriver();
+
+    /**
+     * Closes the connection if it is open
+    */
+    void Close();
+
+    /**
+     * Synchronizes with the X server. Sends a synchronization event and waits for response.
+     * This is done after all input events and is thus unnecessary in regular circumstances.
+    */
+    void Sync();
+
+    /**
+     * All of the functions below result in one input event being sent to the X server
+     * via the FIFO files. If the files are not open yet, an exception is thrown.
+    */
+    void RelMotion(const Valuators& valuators);
+
+    void AbsMotion(const Valuators& valuators);
+
+    void ProximityIn(const Valuators& valuators);
+    void ProximityOut(const Valuators& valuators);
+
+    void ButtonDownAbs(std::int32_t button, const Valuators& valuators);
+    void ButtonDownRel(std::int32_t button, const Valuators& valuators);
+
+    void ButtonUpAbs(std::int32_t button, const Valuators& valuators);
+    void ButtonUpRel(std::int32_t button, const Valuators& valuators);
+
+    void KeyDown(std::int32_t key_code);
+    void KeyUp(std::int32_t key_code);
+
+    void TouchBegin(std::uint32_t id, const Valuators& valuators);
+    void TouchUpdate(std::uint32_t id, const Valuators& valuators);
+    void TouchEnd(std::uint32_t id, const Valuators& valuators);
+
+private:
+    struct Private;
+    std::unique_ptr<Private> d_;
+
+    bool TryConnectToDriver();
+    void EnsureConnectedToDriver();
+};
+
+} // namespace inputtest
+} // namespace testing
+} // namespace xorg
+
+#endif // XORG_INPUTTEST_DRIVER_CONNECTION_H_
diff --git a/gtest/src/valuators.cpp b/gtest/src/valuators.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5f6cd7f54fb243a8125cb9dc3fa882f322be151b
--- /dev/null
+++ b/gtest/src/valuators.cpp
@@ -0,0 +1,87 @@
+/*******************************************************************************
+ *
+ * X testing environment - Google Test environment feat. dummy x server
+ *
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ ******************************************************************************/
+
+#include "xorg/gtest/inputtest/xorg-gtest-valuators.h"
+#include <cstring>
+
+namespace xorg {
+namespace testing {
+namespace inputtest {
+
+static void ValuatorSetBit(std::uint8_t* ptr, unsigned bit)
+{
+    ptr[bit >> 3] |= 1 << (bit & 7);
+}
+
+struct Valuators::Private {
+    Private()
+    {
+        std::memset(&valuators, 0, sizeof(valuators));
+    }
+
+    xf86ITValuatorData valuators;
+};
+
+Valuators::Valuators() : d_{std::unique_ptr<Private>(new Private())} {}
+
+Valuators::Valuators(const Valuators& other) : d_{std::unique_ptr<Private>(new Private())}
+{
+    *d_ = *other.d_;
+}
+
+Valuators& Valuators::operator=(const Valuators& other)
+{
+    *d_ = *other.d_;
+    return *this;
+}
+
+Valuators::~Valuators() {}
+
+Valuators& Valuators::Set(unsigned axis, double value)
+{
+    ValuatorSetBit(d_->valuators.mask, axis);
+    d_->valuators.valuators[axis] = value;
+    return *this;
+}
+
+Valuators& Valuators::SetUnaccel(unsigned axis, double value_accel, double value_unaccel)
+{
+    d_->valuators.has_unaccelerated = true;
+    ValuatorSetBit(d_->valuators.mask, axis);
+    d_->valuators.valuators[axis] = value_accel;
+    d_->valuators.unaccelerated[axis] = value_unaccel;
+    return *this;
+}
+
+void Valuators::RetrieveValuatorData(xf86ITValuatorData* out) const
+{
+    *out = d_->valuators;
+}
+
+} // namespace inputtest
+} // namespace testing
+} // namespace xorg
diff --git a/meson.build b/meson.build
index b3e1a1e8884faa772c574b71b8885b4c2b39c459..a35c9230297edf5829237d671623a3d1f77437a0 100644
--- a/meson.build
+++ b/meson.build
@@ -59,6 +59,8 @@ xorg_gtest_sources = files(
     'gtest/include/xorg/gtest/xorg-gtest-process.h',
     'gtest/include/xorg/gtest/xorg-gtest-test.h',
     'gtest/include/xorg/gtest/xorg-gtest-xserver.h',
+    'gtest/include/xorg/gtest/inputtest/xorg-gtest-device.h',
+    'gtest/include/xorg/gtest/inputtest/xorg-gtest-valuators.h',
     'gtest/include/xorg/gtest/evemu/xorg-gtest-device.h',
     'gtest/include/xorg/gtest/xorg-gtest.h',
 
@@ -68,6 +70,10 @@ xorg_gtest_sources = files(
     'gtest/src/device.cpp',
     'gtest/src/process.cpp',
     'gtest/src/test.cpp',
+    'gtest/src/inputtest-device.cpp',
+    'gtest/src/inputtest-driver-connection.cpp',
+    'gtest/src/inputtest-driver-connection.h',
+    'gtest/src/valuators.cpp',
     'gtest/src/xserver.cpp',
 )
 
@@ -80,6 +86,7 @@ xorg_gtest_dependencies = [
     dep_evemu,
     dep_x11,
     dep_xi,
+    dep_xserver,
 ]
 
 lib_xorg_gtest = static_library('xorg-gtest',
@@ -93,6 +100,7 @@ lib_xorg_gtest = static_library('xorg-gtest',
                                 )
 
 dep_xorg_gtest = declare_dependency(link_with: lib_xorg_gtest,
+                                    dependencies: [dep_xserver],
                                     include_directories: [gtest_includes, xorg_gtest_incs])
 
 
@@ -158,6 +166,8 @@ common_sources = files(
 		 'tests/common/helpers.h',
 		 'tests/common/device-interface.cpp',
 		 'tests/common/device-interface.h',
+		 'tests/common/device-inputtest-interface.cpp',
+		 'tests/common/device-inputtest-interface.h',
 		 'tests/common/video-driver-test.h',
 )
 
@@ -193,6 +203,7 @@ lib_xit = static_library('xit',
 
 )
 dep_xit = declare_dependency(link_with: lib_xit,
+			     dependencies: [dep_xorg_gtest],
 			     include_directories: xit_includes)
 
 
diff --git a/tests/common/device-inputtest-interface.cpp b/tests/common/device-inputtest-interface.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..fb4c8e2e3db3e9a1f552de8b653a3f750bc4123c
--- /dev/null
+++ b/tests/common/device-inputtest-interface.cpp
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include "device-inputtest-interface.h"
+#include <stdexcept>
+#include <string>
+
+namespace {
+    // FIXME: this should be replaced with std::filesystem::temp_directory_path() when we can use
+    // c++17
+    std::string GetTemporaryDirectoryPath()
+    {
+        const char* env_variables[] = {
+            "TMPDIR",
+            "TMP",
+            "TEMP",
+            "TEMPDIR"
+        };
+        for (const char* env : env_variables) {
+            const char* path = std::getenv(env);
+            if (path)
+                return path;
+        }
+        return "/tmp";
+    }
+
+    std::string GetSocketPath(const std::string& identifier)
+    {
+        return GetTemporaryDirectoryPath() + "/" + identifier;
+    }
+
+    int s_device_counter = 0;
+} // namespace
+
+void DeviceInputTestInterface::AddDevice(xorg::testing::inputtest::DeviceType device_type)
+{
+    s_device_counter++;
+    auto path = GetSocketPath("xit_events_socket_" + std::to_string(s_device_counter) + "_" +
+                                  std::to_string(devices.size()));
+    devices.push_back(std::unique_ptr<xorg::testing::inputtest::Device>(
+        new xorg::testing::inputtest::Device(path, device_type)));
+}
+
+xorg::testing::inputtest::Device& DeviceInputTestInterface::Dev(unsigned i)
+{
+    if (i >= devices.size()) {
+        throw std::runtime_error("Device does not exist");
+    }
+    if (!devices[i]) {
+        throw std::runtime_error("Device has been removed");
+    }
+    return *devices[i];
+}
+
+void DeviceInputTestInterface::WaitForDevices()
+{
+    for (const auto& dev : devices) {
+        if (!dev)
+            continue;
+        dev->WaitForDriver();
+    }
+}
diff --git a/tests/common/device-inputtest-interface.h b/tests/common/device-inputtest-interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..6462e7712c85f61b29d344b1dd840024dcb9208b
--- /dev/null
+++ b/tests/common/device-inputtest-interface.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2020 Povilas Kanapickas <povilas@radix.lt>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#ifndef DEVICE_INPUTTEST_INTERFACE_H_
+#define DEVICE_INPUTTEST_INTERFACE_H_
+
+#include <xorg/gtest/xorg-gtest.h>
+
+/**
+ * A test fixture for testing X server input processing.
+ *
+ * Do not instantiate this class directly, subclass it from the test case
+ * instead.
+ */
+class DeviceInputTestInterface {
+protected:
+    xorg::testing::inputtest::Device& Dev(unsigned i);
+
+    void WaitForDevices();
+
+    void AddDevice(xorg::testing::inputtest::DeviceType device_type);
+
+private:
+    // devices must have unique, non-reused IDs within a single test run. If we ever want to remove
+    // a device, just clear the stored device.
+    std::vector<std::unique_ptr<xorg::testing::inputtest::Device>> devices;
+};
+
+#endif
diff --git a/tests/common/device-interface.h b/tests/common/device-interface.h
index 45588fc82998503c982b46af9920ddc07ef02a6f..4afd71ef0c2585fcb003a4e68e964cd090d38bc8 100644
--- a/tests/common/device-interface.h
+++ b/tests/common/device-interface.h
@@ -36,7 +36,7 @@
  * A test fixture for testing input drivers. This class automates basic
  * device setup throught the server config file.
  *
- * Do not instanciate this class directly, subclass it from the test case
+ * Do not instantiate this class directly, subclass it from the test case
  * instead. For simple test cases, use SimpleInputDriverTest.
  */
 class DeviceInterface {
diff --git a/tests/common/xorg-conf.cpp b/tests/common/xorg-conf.cpp
index aa1359c8516e46fc139dffc328271d995571dca4..5fb716c86179044d7b4143d2ffb78ef09e75122b 100644
--- a/tests/common/xorg-conf.cpp
+++ b/tests/common/xorg-conf.cpp
@@ -69,6 +69,8 @@ void XOrgConfig::WriteConfig(const std::string &path) {
             conffile << "    Screen 0 \"" << default_device << " screen\" 0 0\n";
         for (it = input_devices.begin(); it != input_devices.end(); it++)
             conffile << "    InputDevice \"" << *it << "\"\n";
+        for (it = server_layout_opts.begin(); it != server_layout_opts.end(); ++it)
+            conffile << *it << "\n";
         conffile << "EndSection\n";
     }
 
@@ -105,6 +107,11 @@ void XOrgConfig::AddDefaultScreenWithDriver(const std::string &driver,
     sections.push_back(section.str());
 }
 
+void XOrgConfig::AddServerLayoutOption(const std::string& option)
+{
+    server_layout_opts.push_back(option);
+}
+
 void XOrgConfig::AddInputSection(const std::string &driver,
                                  const std::string &identifier,
                                  const std::string &options,
diff --git a/tests/common/xorg-conf.h b/tests/common/xorg-conf.h
index d6e8836c31202f43b41acda8fd1d5c8822f163f7..6e8ed67c96b73c4f7590e4f15c0724f952bab4bc 100644
--- a/tests/common/xorg-conf.h
+++ b/tests/common/xorg-conf.h
@@ -86,6 +86,16 @@ public:
      */
     virtual void RemoveConfig();
 
+    /**
+     * Add an option to the server layout.
+     * Options may be specified by the caller and must be a single string.
+     * It is recommened that multiple options are separated by line-breaks
+     * to improve the readability of the config file.
+     *
+     * @param option Option in the form "<option name> <values>"
+     */
+    void AddServerLayoutOption(const std::string& option);
+
     /**
      * Add a Section InputDevice to the config file. This section is
      * optionally referenced from the ServerLayout written by this section,
@@ -178,6 +188,7 @@ protected:
     std::string config_file;
     std::vector<std::string> sections;
     std::vector<std::string> input_devices;
+    std::vector<std::string> server_layout_opts;
     std::string default_device;
     bool auto_add_devices;
 };
diff --git a/tests/lib/libXi.cpp b/tests/lib/libXi.cpp
index 1d0bc155689e4d778f432b2bef69b913ab1df0aa..cf59b2e4ced1f6bd2e96b7122f0085ae7395e037 100644
--- a/tests/lib/libXi.cpp
+++ b/tests/lib/libXi.cpp
@@ -35,23 +35,23 @@
 
 #include <xit-server-input-test.h>
 #include <xit-property.h>
-#include <device-interface.h>
+#include <device-inputtest-interface.h>
 
 #include "helpers.h"
 #include "xit-event.h"
 
 /**
- * Test for libXi-related bugs. Initialises a single evdev pointer device ready
- * for uinput-events.
+ * Test for libXi-related bugs. Initialises a single test pointer device.
  */
 class libXiTest : public XITServerInputTest,
-                  public DeviceInterface {
+                  public DeviceInputTestInterface {
 public:
     /**
      * Initializes a standard mouse device with two wheels.
      */
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XITServerInputTest::SetUp();
     }
 
@@ -62,16 +62,22 @@ public:
     virtual void SetUpConfigAndLog() {
 
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "keyboard-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--keyboard-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
 
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 TEST_F(libXiTest, DisplayNotGarbage)
@@ -92,7 +98,7 @@ TEST_F(libXiTest, DisplayNotGarbage)
     XISelectEvents(dpy, DefaultRootWindow(dpy), &mask, 1);
     XSync(dpy, False);
 
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(-1, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
@@ -122,8 +128,8 @@ TEST_F(libXiTest, SerialNumberNotGarbage)
     /* XIDeviceEvent */
     SelectXI2Events(dpy, VIRTUAL_CORE_POINTER_ID, DefaultRootWindow(dpy),
                     XI_Motion, -1);
-    dev->PlayOne(EV_REL, REL_X, -1, true);
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(-1, 0);
+    Dev(0).RelMotion(-1, 0);
 
     ASSERT_EVENT(XIDeviceEvent, motion1, dpy, GenericEvent, xi2_opcode, XI_Motion);
     ASSERT_EVENT(XIDeviceEvent, motion2, dpy, GenericEvent, xi2_opcode, XI_Motion);
@@ -131,7 +137,8 @@ TEST_F(libXiTest, SerialNumberNotGarbage)
 
     XSync(dpy, True);
 
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(-1, 0);
+
     ASSERT_EVENT(XIDeviceEvent, motion3, dpy, GenericEvent, xi2_opcode, XI_Motion);
     EXPECT_LT(motion2->serial, motion3->serial);
 
@@ -139,8 +146,10 @@ TEST_F(libXiTest, SerialNumberNotGarbage)
     XSync(dpy, True);
     SelectXI2Events(dpy, VIRTUAL_CORE_POINTER_ID, DefaultRootWindow(dpy),
                     XI_RawMotion, -1);
-    dev->PlayOne(EV_REL, REL_X, -1, true);
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+
+    Dev(0).RelMotion(-1, 0);
+    Dev(0).RelMotion(-1, 0);
+
     ASSERT_EVENT(XIDeviceEvent, raw1, dpy, GenericEvent, xi2_opcode, XI_RawMotion);
     ASSERT_EVENT(XIDeviceEvent, raw2, dpy, GenericEvent, xi2_opcode, XI_RawMotion);
     EXPECT_GT(raw2->serial, motion3->serial);
@@ -148,7 +157,8 @@ TEST_F(libXiTest, SerialNumberNotGarbage)
 
     XSync(dpy, True);
 
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(-1, 0);
+
     ASSERT_EVENT(XIDeviceEvent, raw3, dpy, GenericEvent, xi2_opcode, XI_RawMotion);
     EXPECT_LT(raw2->serial, raw3->serial);
 
@@ -175,17 +185,44 @@ TEST_F(libXiTest, SerialNumberNotGarbage)
     /* FIXME: should check other events too */
 }
 
-class libXiTouchTest : public libXiTest {
+class libXiTouchTest : public XITServerInputTest,
+                       public DeviceInputTestInterface {
 public:
     /**
-     * Initializes a standard mouse device with two wheels.
+     * Initializes a touchpad device
      */
     virtual void SetUp() {
-        SetDevice("tablets/N-Trig-MultiTouch.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XITServerInputTest::SetUp();
     }
+
+    /**
+     * Sets up an xorg.conf for a single evdev CorePointer device based on
+     * the evemu device.
+     */
+    virtual void SetUpConfigAndLog() {
+
+        config.AddDefaultScreenWithDriver();
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
+                               "Option \"CorePointer\" \"on\"\n"
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--keyboard-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
+        config.WriteConfig();
+    }
+
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
+
 TEST_F(libXiTouchTest, CopyRawTouchEvent)
 {
     XORG_TESTCASE("Generate touch begin/end event\n"
@@ -208,9 +245,9 @@ TEST_F(libXiTouchTest, CopyRawTouchEvent)
     XISelectEvents(dpy, DefaultRootWindow(dpy), &mask, 1);
     XSync(dpy, False);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_update.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(200, 200, 0);
+    Dev(0).TouchUpdate(210, 210, 0);
+    Dev(0).TouchEnd(210, 210, 0);
 
     XSync(dpy, False);
     ASSERT_GT(XPending(dpy), 0);
diff --git a/tests/server/barriers-common.h b/tests/server/barriers-common.h
index 04b9f29ddccf098cb2d332643f9c76ef5fc90522..4b2f7cb6f0c476355fc3ce9d1f1065552f3d654d 100644
--- a/tests/server/barriers-common.h
+++ b/tests/server/barriers-common.h
@@ -32,7 +32,7 @@
 #include <xorg/gtest/xorg-gtest.h>
 
 #include "xit-server-input-test.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 
 class BarrierBaseTest : public XITServerInputTest {
 public:
@@ -63,66 +63,66 @@ public:
 };
 
 class BarrierTest : public BarrierBaseTest,
-                    public DeviceInterface {
+                    public DeviceInputTestInterface {
 public:
 
     /**
      * Initializes a standard mouse device.
      */
-    virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         BarrierBaseTest::SetUp();
     }
 
+    void StartServer() override {
+        BarrierBaseTest::StartServer();
+        WaitForDevices();
+    }
+
+
     /**
-     * Sets up an xorg.conf for a single evdev CoreKeyboard device based on
-     * the evemu device. The input from GetParam() is used as XkbLayout.
+     * Sets up an xorg.conf for a single test CoreKeyboard device based on
+     * the test device. The input from GetParam() is used as XkbLayout.
      */
-    virtual void SetUpConfigAndLog() {
+    void SetUpConfigAndLog() override {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
                                "Option \"GrabDevice\" \"on\"\n"
                                /* Disable pointer acceleration to allow for accurate
-                                * pointer positions with EV_REL events... */
-                               "Option \"AccelerationProfile\" \"-1\""
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                                * pointer positions with relative events... */
+                               "Option \"AccelerationProfile\" \"-1\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-kbd--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
 };
 
-class BarrierDevices : public BarrierBaseTest {
+class BarrierDevices : public BarrierBaseTest,
+                       public DeviceInputTestInterface {
 public:
-    std::unique_ptr<xorg::testing::evemu::Device> dev1;
-    std::unique_ptr<xorg::testing::evemu::Device> dev2;
-
     int master_id_1;
     int master_id_2;
 
-    virtual void SetUp() {
-        SetUpDevices();
-
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         xi2_major_minimum = 2;
         xi2_minor_minimum = 3;
 
-
         BarrierBaseTest::SetUp();
         ConfigureDevices();
     }
 
-    virtual void SetUpDevices() {
-        dev1 = std::unique_ptr<xorg::testing::evemu::Device>(
-                new xorg::testing::evemu::Device(
-                    RECORDINGS_DIR "mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc"
-                ));
-        dev2 = std::unique_ptr<xorg::testing::evemu::Device>(
-                new xorg::testing::evemu::Device(
-                    RECORDINGS_DIR "mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc"
-                ));
+    void StartServer() override {
+        BarrierBaseTest::StartServer();
+        WaitForDevices();
     }
 
     void ConfigureDevices() {
@@ -140,7 +140,7 @@ public:
         ASSERT_EQ(XIChangeHierarchy(dpy, &change, 1), Success) << "Couldn't add the new master device.";
         ASSERT_TRUE(xorg::testing::XServer::WaitForDevice(dpy, "New Master pointer")) << "Didn't get the new master pointer device.";
         ASSERT_TRUE(FindInputDeviceByName(dpy, "New Master pointer", &master_id_2)) << "Failed to find the new master pointer.";
-        ASSERT_TRUE(FindInputDeviceByName(dpy, "--device2--", &device_id_2)) << "Failed to find device2.";
+        ASSERT_TRUE(FindInputDeviceByName(dpy, "--device1--", &device_id_2)) << "Failed to find device2.";
 
         change.attach.type = XIAttachSlave;
         change.attach.deviceid = device_id_2;
@@ -163,22 +163,24 @@ public:
 
     virtual void SetUpConfigAndLog() {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device1--",
-                               "Option \"Emulate3Buttons\" \"off\""
-                               "Option \"CorePointer\" \"on\""
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device0--",
+                               "Option \"CorePointer\" \"on\"\n"
                                "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"AccelerationProfile\" \"-1\""
-                               "Option \"Device\" \"" + dev1->GetDeviceNode() + "\"");
-
-        config.AddInputSection("evdev", "--device2--",
-                               "Option \"Emulate3Buttons\" \"off\""
-                               "Option \"CorePointer\" \"on\""
+                               /* Disable pointer acceleration to allow for accurate
+                                * pointer positions with relative events... */
+                               "Option \"AccelerationProfile\" \"-1\"" +
+                               Dev(0).GetOptions());
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device1--",
+                               "Option \"CorePointer\" \"on\"\n"
                                "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"AccelerationProfile\" \"-1\""
-                               "Option \"Device\" \"" + dev2->GetDeviceNode() + "\"");
-
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               /* Disable pointer acceleration to allow for accurate
+                                * pointer positions with relative events... */
+                               "Option \"AccelerationProfile\" \"-1\"\n" +
+                               Dev(1).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device2--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(2).GetOptions());
         config.WriteConfig();
     }
 };
diff --git a/tests/server/barriers-devices.cpp b/tests/server/barriers-devices.cpp
index ccf767e5be9492f249fcfe34f9f01de20bce2ec9..de2ab980d5ef01c09e07cee6805ccee682b18908 100644
--- a/tests/server/barriers-devices.cpp
+++ b/tests/server/barriers-devices.cpp
@@ -38,7 +38,7 @@
 
 #if HAVE_FIXES5
 
-using namespace xorg::testing::evemu;
+using namespace xorg::testing::inputtest;
 
 static Bool
 QueryPointerPosition(Display *dpy, int device_id,
@@ -87,10 +87,13 @@ TEST_F(BarrierDevices, BarrierBlocksCorrectDevices)
 
     /* Make sure that the VCP is blocked when going across
      * the barrier, but the other device is not. */
-    dev1->PlayOne(EV_REL, REL_X, 100, True);
+
+    Dev(0).RelMotion(100, 0);
+
     ASSERT_PTR_POS(master_id_1, 49, 30);
 
-    dev2->PlayOne(EV_REL, REL_X, 100, True);
+    Dev(1).RelMotion(100, 0);
+
     ASSERT_PTR_POS(master_id_2, 130, 30);
 
     /* Assume that if all the other warp and directions tests
diff --git a/tests/server/barriers-directions.cpp b/tests/server/barriers-directions.cpp
index f6da5b06742b3c327a4f3a0127adac7d771517ca..4e7a89b9db10a80ead4f1f6145960aa0088bee1e 100644
--- a/tests/server/barriers-directions.cpp
+++ b/tests/server/barriers-directions.cpp
@@ -80,7 +80,7 @@ TEST_F(BarrierConstrained, VerticalBarrierNoDirectionBlocksMotion)
     ASSERT_PTR_POS(50, 30);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_X, -100, True);
+    Dev(0).RelMotion(-100, 0);
     ASSERT_PTR_POS(20, 30);
 
     /* Warp the pointer to before the barrier. */
@@ -89,7 +89,7 @@ TEST_F(BarrierConstrained, VerticalBarrierNoDirectionBlocksMotion)
     ASSERT_PTR_POS(10, 30);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_X, 100, True);
+    Dev(0).RelMotion(100, 0);
     ASSERT_PTR_POS(19, 30);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
@@ -127,7 +127,7 @@ TEST_F(BarrierConstrained, VerticalBarrierPositiveXBlocksMotion)
     ASSERT_PTR_POS(50, 30);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_X, -100, True);
+    Dev(0).RelMotion(-100, 0);
     ASSERT_PTR_POS(20, 30);
 
     /* Warp the pointer to before the barrier. */
@@ -136,7 +136,7 @@ TEST_F(BarrierConstrained, VerticalBarrierPositiveXBlocksMotion)
     ASSERT_PTR_POS(10, 30);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_X, 100, True);
+    Dev(0).RelMotion(100, 0);
     ASSERT_PTR_POS(110, 30);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
@@ -174,7 +174,7 @@ TEST_F(BarrierConstrained, VerticalBarrierNegativeXBlocksMotion)
     ASSERT_PTR_POS(50, 30);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_X, -100, True);
+    Dev(0).RelMotion(-100, 0);
     ASSERT_PTR_POS(0, 30);
 
     /* Warp the pointer to before the barrier. */
@@ -183,7 +183,7 @@ TEST_F(BarrierConstrained, VerticalBarrierNegativeXBlocksMotion)
     ASSERT_PTR_POS(10, 30);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_X, 100, True);
+    Dev(0).RelMotion(100, 0);
     ASSERT_PTR_POS(19, 30);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
@@ -222,7 +222,7 @@ TEST_F(BarrierConstrained, VerticalBarrierBothDirectionsXBlocksNoMotion)
     ASSERT_PTR_POS(50, 30);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_X, -100, True);
+    Dev(0).RelMotion(-100, 0);
     ASSERT_PTR_POS(0, 30);
 
     /* Warp the pointer to before the barrier. */
@@ -231,7 +231,7 @@ TEST_F(BarrierConstrained, VerticalBarrierBothDirectionsXBlocksNoMotion)
     ASSERT_PTR_POS(10, 30);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_X, 100, True);
+    Dev(0).RelMotion(100, 0);
     ASSERT_PTR_POS(110, 30);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
@@ -270,7 +270,7 @@ TEST_F(BarrierConstrained, HorizontalBarrierNoDirectionBlocksMotion)
     ASSERT_PTR_POS(30, 50);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, -100, True);
+    Dev(0).RelMotion(0, -100);
     ASSERT_PTR_POS(30, 20);
 
     /* Warp the pointer to before the barrier. */
@@ -279,7 +279,7 @@ TEST_F(BarrierConstrained, HorizontalBarrierNoDirectionBlocksMotion)
     ASSERT_PTR_POS(30, 10);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, 100, True);
+    Dev(0).RelMotion(0, 100);
     ASSERT_PTR_POS(30, 19);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
@@ -317,7 +317,7 @@ TEST_F(BarrierConstrained, HorizontalBarrierPositiveYBlocksMotion)
     ASSERT_PTR_POS(30, 50);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, -100, True);
+    Dev(0).RelMotion(0, -100);
     ASSERT_PTR_POS(30, 20);
 
     /* Warp the pointer to before the barrier. */
@@ -326,7 +326,7 @@ TEST_F(BarrierConstrained, HorizontalBarrierPositiveYBlocksMotion)
     ASSERT_PTR_POS(30, 10);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, 100, True);
+    Dev(0).RelMotion(0, 100);
     ASSERT_PTR_POS(30, 110);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
@@ -364,7 +364,7 @@ TEST_F(BarrierConstrained, HoritzontalBarrierNegativeYBlocksMotion)
     ASSERT_PTR_POS(30, 50);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, -100, True);
+    Dev(0).RelMotion(0, -100);
     ASSERT_PTR_POS(30, 0);
 
     /* Warp the pointer to before the barrier. */
@@ -373,7 +373,7 @@ TEST_F(BarrierConstrained, HoritzontalBarrierNegativeYBlocksMotion)
     ASSERT_PTR_POS(30, 10);
 
     /* This should be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, 100, True);
+    Dev(0).RelMotion(0, 100);
     ASSERT_PTR_POS(30, 19);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
@@ -412,7 +412,7 @@ TEST_F(BarrierConstrained, HorizontalBarrierBothDirectionsYBlocksNoMotion)
     ASSERT_PTR_POS(30, 50);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, -100, True);
+    Dev(0).RelMotion(0, -100);
     ASSERT_PTR_POS(30, 0);
 
     /* Warp the pointer to before the barrier. */
@@ -421,7 +421,7 @@ TEST_F(BarrierConstrained, HorizontalBarrierBothDirectionsYBlocksNoMotion)
     ASSERT_PTR_POS(30, 10);
 
     /* This shouldn't be blocked. */
-    dev->PlayOne(EV_REL, REL_Y, 100, True);
+    Dev(0).RelMotion(0, 100);
     ASSERT_PTR_POS(30, 110);
 
     XFixesDestroyPointerBarrier (dpy, barrier);
diff --git a/tests/server/barriers-notify.cpp b/tests/server/barriers-notify.cpp
index d92745d9ca53a85a31e304504272f53988c65e21..b5646ab2a29e74875c6d1fa0258d1c6fdf12f594 100644
--- a/tests/server/barriers-notify.cpp
+++ b/tests/server/barriers-notify.cpp
@@ -39,7 +39,7 @@
 
 #if HAVE_XI23
 
-using namespace xorg::testing::evemu;
+using namespace xorg::testing::inputtest;
 
 enum BarrierDeviceTestCombinations {
     NO_DEVICE_SPECIFICS, /**< test with no barrier device ID specified */
@@ -96,14 +96,16 @@ static std::string enum_to_string(enum BarrierDeviceTestCombinations b) {
 class BarrierNotify : public BarrierDevices,
                       public ::testing::WithParamInterface<enum BarrierDeviceTestCombinations> {
 public:
-    std::unique_ptr<Device>* target_dev;
+    Device* target_dev;
     int ndevices;
     int deviceid;
     int sourceid;
     int all_deviceids[2];
 
     virtual void SetUp(){
-        SetUpDevices();
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         xi2_major_minimum = 2;
         xi2_minor_minimum = 3;
@@ -138,53 +140,53 @@ public:
 
         switch(combination) {
             case NO_DEVICE_SPECIFICS:
-                target_dev = &dev1;
+                target_dev = &Dev(0);
                 deviceid = VIRTUAL_CORE_POINTER_ID;
                 ndevices = 0;
-                source_dev = "--device1--";
+                source_dev = "--device0--";
                 break;
             case TARGET_VCP:
             case VCP_ONLY:
                 ndevices = 1;
                 deviceid = VIRTUAL_CORE_POINTER_ID;
-                target_dev = &dev1;
-                source_dev = "--device1--";
+                target_dev = &Dev(0);
+                source_dev = "--device0--";
                 all_deviceids[0] = VIRTUAL_CORE_POINTER_ID;
                 break;
             case TARGET_POINTER2:
                 ndevices = 1;
                 deviceid = master_id_2;
-                target_dev = &dev2;
-                source_dev = "--device2--";
+                target_dev = &Dev(1);
+                source_dev = "--device1--";
                 all_deviceids[0] = master_id_2;
                 break;
             case TARGET_VCP_AND_ALL:
                 ndevices = 2;
                 deviceid = VIRTUAL_CORE_POINTER_ID;
-                target_dev = &dev1;
-                source_dev = "--device1--";
+                target_dev = &Dev(0);
+                source_dev = "--device0--";
                 all_deviceids[0] = VIRTUAL_CORE_POINTER_ID;
                 all_deviceids[1] = master_id_2;
                 break;
             case TARGET_POINTER2_AND_ALL:
                 ndevices = 2;
                 deviceid = master_id_2;
-                target_dev = &dev2;
-                source_dev = "--device2--";
+                target_dev = &Dev(1);
+                source_dev = "--device1--";
                 all_deviceids[0] = VIRTUAL_CORE_POINTER_ID;
                 all_deviceids[1] = master_id_2;
                 break;
             case LATE_SECOND_MD_VCP:
                 ndevices = 0;
                 deviceid = -1;
-                target_dev = &dev1;
-                source_dev = "--device1--";
+                target_dev = &Dev(0);
+                source_dev = "--device0--";
                 break;
             case LATE_SECOND_MD_POINTER2:
                 ndevices = 0;
                 deviceid = -1;
-                target_dev = &dev2;
-                source_dev = "--device2--";
+                target_dev = &Dev(1);
+                source_dev = "--device1--";
                 break;
             default:
                 FAIL();
@@ -244,7 +246,7 @@ TEST_P(BarrierNotify, ReceivesNotifyEvents)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XSync(dpy, False);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
 
     /* Ensure we have a BarrierHit on our hands. */
     XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -283,7 +285,7 @@ TEST_P(BarrierNotify, CorrectEventIDs)
 
     /* Ensure we have a bunch of BarrierHits on our hands. */
     for (int i = 0; i < 10; i++) {
-        (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+        target_dev->RelMotion(-40, 0);
 
         /* Ensure we have a BarrierHit on our hands. */
         XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -306,13 +308,14 @@ TEST_P(BarrierNotify, CorrectEventIDs)
 
     /* Move outside the hitbox, and ensure that we
      * get a BarrierLeave */
-    (*target_dev)->PlayOne(EV_REL, REL_X, 20, true);
+    target_dev->RelMotion(20, 0);
+
     XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierLeave);
     ASSERT_EQ(barrier, event.ev->barrier);
     ASSERT_EQ(1U, event.ev->eventid);
 
     for (int i = 0; i < 10; i++) {
-        (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+        target_dev->RelMotion(-40, 0);
 
         XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
         ASSERT_TRUE(event.ev);
@@ -329,10 +332,10 @@ TEST_P(BarrierNotify, CorrectEventIDs)
 
     /* Ensure that we're still inside the hit box. Event ID
      * should stay the same on such a minor change. */
-    (*target_dev)->PlayOne(EV_REL, REL_X, 1, true);
+    target_dev->RelMotion(1, 0);
 
     for (int i = 0; i < 10; i++) {
-        (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+        target_dev->RelMotion(-40, 0);
 
         XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
         ASSERT_EQ(barrier, event.ev->barrier);
@@ -369,7 +372,8 @@ TEST_P(BarrierNotify, BarrierReleases)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XSync(dpy, False);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
+
     {
         XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
         ASSERT_TRUE(event.ev);
@@ -383,7 +387,7 @@ TEST_P(BarrierNotify, BarrierReleases)
     XIBarrierReleasePointer(dpy, deviceid, barrier, 1);
     XSync(dpy, False);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
 
     /* We should have a new event because we exited the hit box */
     {
@@ -426,7 +430,7 @@ TEST_P(BarrierNotify, DestroyWindow)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XSync(dpy, False);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
 
     /* Ensure we have a BarrierHit on our hands. */
     XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -441,7 +445,7 @@ TEST_P(BarrierNotify, DestroyWindow)
     XDestroyWindow(dpy, win);
     XSync(dpy, True);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
 
     double x, y;
     QueryPointerPosition(dpy, &x, &y, deviceid);
@@ -482,7 +486,7 @@ TEST_P(BarrierNotify, UnmapWindow)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XSync(dpy, False);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
 
     /* Ensure we have a BarrierHit on our hands. */
     XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -497,7 +501,7 @@ TEST_P(BarrierNotify, UnmapWindow)
     XUnmapWindow(dpy, win);
     XSync(dpy, True);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
 
     double x, y;
     QueryPointerPosition(dpy, &x, &y, deviceid);
@@ -551,7 +555,9 @@ TEST_P(BarrierNotify, EventsDuringActiveGrab)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &event_mask, 1);
     XIGrabDevice(dpy, deviceid, root, CurrentTime, None, GrabModeAsync, GrabModeAsync, True, &no_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -570,14 +576,18 @@ TEST_P(BarrierNotify, EventsDuringActiveGrab)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &event_mask, 1);
     XIGrabDevice(dpy, deviceid, root, CurrentTime, None, GrabModeAsync, GrabModeAsync, False, &no_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_FALSE(xorg::testing::XServer::WaitForEvent(dpy, 500));
 
     /* if OE is true and mask is set → event */
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &no_mask, 1);
     XIGrabDevice(dpy, deviceid, root, CurrentTime, None, GrabModeAsync, GrabModeAsync, True, &event_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -596,7 +606,9 @@ TEST_P(BarrierNotify, EventsDuringActiveGrab)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &no_mask, 1);
     XIGrabDevice(dpy, deviceid, root, CurrentTime, None, GrabModeAsync, GrabModeAsync, False, &event_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -645,7 +657,9 @@ TEST_P(BarrierNotify, EventsDuringActiveGrabNonGrabWindow)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &event_mask, 1);
     XIGrabDevice(dpy, deviceid, win, CurrentTime, None, GrabModeAsync, GrabModeAsync, True, &no_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -663,7 +677,9 @@ TEST_P(BarrierNotify, EventsDuringActiveGrabNonGrabWindow)
     /* if OE is false and mask is not set, but set on window → event */
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XIGrabDevice(dpy, deviceid, win, CurrentTime, None, GrabModeAsync, GrabModeAsync, False, &no_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -681,7 +697,9 @@ TEST_P(BarrierNotify, EventsDuringActiveGrabNonGrabWindow)
     /* if OE is true and mask is set → event */
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XIGrabDevice(dpy, deviceid, win, CurrentTime, None, GrabModeAsync, GrabModeAsync, True, &event_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -699,7 +717,9 @@ TEST_P(BarrierNotify, EventsDuringActiveGrabNonGrabWindow)
     /* if OE is false and mask is set → event */
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XIGrabDevice(dpy, deviceid, win, CurrentTime, None, GrabModeAsync, GrabModeAsync, False, &event_mask);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -750,7 +770,9 @@ TEST_P(BarrierNotify, EventsDuringActiveGrabOtherClient)
     /* We still expect events */
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &event_mask, 1);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+
+    target_dev->RelMotion(-40, 0);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -810,9 +832,11 @@ TEST_P(BarrierNotify, EventsDuringPassiveGrab)
     XISelectEvents(dpy, root, &event_mask, 1);
     XIGrabButton(dpy, deviceid, 1, root, None, GrabModeAsync, GrabModeAsync, True, &no_mask, 1, &mods);
     XSync(dpy, False);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+
+    target_dev->ButtonDown(1);
+    target_dev->RelMotion(-40, 0);
+    target_dev->ButtonUp(1);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -832,9 +856,11 @@ TEST_P(BarrierNotify, EventsDuringPassiveGrab)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &event_mask, 1);
     XIGrabButton(dpy, deviceid, 1, root, None, GrabModeAsync, GrabModeAsync, False, &no_mask, 1, &mods);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+
+    target_dev->ButtonDown(1);
+    target_dev->RelMotion(-40, 0);
+    target_dev->ButtonUp(1);
+
     {
         XITEvent<XIDeviceEvent> press(dpy, GenericEvent, xi2_opcode, XI_ButtonPress);
         ASSERT_TRUE(press.ev);
@@ -847,9 +873,11 @@ TEST_P(BarrierNotify, EventsDuringPassiveGrab)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &no_mask, 1);
     XIGrabButton(dpy, deviceid, 1, root, None, GrabModeAsync, GrabModeAsync, True, &event_mask, 1, &mods);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+
+    target_dev->ButtonDown(1);
+    target_dev->RelMotion(-40, 0);
+    target_dev->ButtonUp(1);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -869,9 +897,11 @@ TEST_P(BarrierNotify, EventsDuringPassiveGrab)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XISelectEvents(dpy, root, &no_mask, 1);
     XIGrabButton(dpy, deviceid, 1, root, None, GrabModeAsync, GrabModeAsync, False, &event_mask, 1, &mods);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
-    (*target_dev)->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+
+    target_dev->ButtonDown(1);
+    target_dev->RelMotion(-40, 0);
+    target_dev->ButtonUp(1);
+
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, GenericEvent, xi2_opcode, XI_BarrierHit, 500));
     {
         XITEvent<XIBarrierEvent> hit(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
@@ -929,8 +959,7 @@ TEST_P(BarrierNotify, BarrierRandREventsVertical)
     ConfigureLateDevices(combination);
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, w - 40 , h - 30);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, 40, false);
-    (*target_dev)->PlayOne(EV_REL, REL_Y, 100, true);
+    target_dev->RelMotion(40, 100);
 
     XITEvent<XIBarrierEvent> event(dpy, GenericEvent, xi2_opcode, XI_BarrierHit);
     ASSERT_EQ(barrier, event.ev->barrier);
@@ -964,7 +993,7 @@ TEST_P(BarrierNotify, ReceivesLeaveOnDestroyWhenInsideHitbox)
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XSync(dpy, False);
 
-    (*target_dev)->PlayOne(EV_REL, REL_X, -40, true);
+    target_dev->RelMotion(-40, 0);
 
     /* Ensure we have a BarrierHit on our hands. */
     {
@@ -1010,7 +1039,7 @@ TEST_P(BarrierNotify, DoesntReceiveLeaveOnDestroyWhenOutsideHitbox)
     XSync(dpy, False);
 
     /* Move the pointer, but don't hit the barrier. */
-    (*target_dev)->PlayOne(EV_REL, REL_X, -5, true);
+    target_dev->RelMotion(-5, 0);
 
     XIWarpPointer(dpy, deviceid, None, root, 0, 0, 0, 0, 30, 30);
     XFixesDestroyPointerBarrier(dpy, barrier);
@@ -1050,7 +1079,7 @@ TEST_F(BarrierMPXTest, BarrierLeaveOnMDDestroyWhenInsideHitbox)
 
     XIWarpPointer(dpy, master_id_2, None, root, 0, 0, 0, 0, 30, 30);
 
-    dev2->PlayOne(EV_REL, REL_X, -40, true);
+    Dev(1).RelMotion(-40, 0);
 
     /* Ensure we have a BarrierHit on our hands. */
     {
diff --git a/tests/server/barriers-validity.cpp b/tests/server/barriers-validity.cpp
index 56b3b547a5fc191f86116d140353a47f0ba15c19..93820100f38baa2ffdbd2abfd0ace859ecb2df98 100644
--- a/tests/server/barriers-validity.cpp
+++ b/tests/server/barriers-validity.cpp
@@ -106,7 +106,7 @@ TEST_F(BarrierSimpleTest, MultipleClientSecurity)
     XSync(dpy1, False);
     XSync(dpy2, False);
 
-    dev->PlayOne(EV_REL, REL_X, -40, True);
+    Dev(0).RelMotion(-40, 0);
 
     XITEvent<XIBarrierEvent> event(dpy1, GenericEvent, xi2_opcode, XI_BarrierHit);
     ASSERT_EQ(XPending(dpy2), 0);
diff --git a/tests/server/dga.cpp b/tests/server/dga.cpp
index c3935b47f40863f99d9f10651e89c924265ddec2..cabdaf948179942aed2b3410abfe43479d273c9d 100644
--- a/tests/server/dga.cpp
+++ b/tests/server/dga.cpp
@@ -30,7 +30,7 @@
 #include <tuple>
 
 #include "helpers.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 #include "xit-server-input-test.h"
 #include "xit-event.h"
 
@@ -56,24 +56,31 @@ public:
 };
 
 class DGAPointerTest : public DGATest,
-                       public DeviceInterface {
+                       public DeviceInputTestInterface {
 public:
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         DGATest::SetUp();
     }
 
     virtual void SetUpConfigAndLog() {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--kbd-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 TEST_F(DGAPointerTest, StuckPointerButtonDuringGrab)
@@ -98,7 +105,7 @@ TEST_F(DGAPointerTest, StuckPointerButtonDuringGrab)
     XDGAMode *modes = XDGAQueryModes(dpy, DefaultScreen(dpy), &nmodes);
     ASSERT_GT(nmodes, 0);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
+    Dev(0).ButtonDown(1);
 
     ASSERT_EVENT(XButtonEvent, press, dpy, ButtonPress);
 
@@ -109,7 +116,7 @@ TEST_F(DGAPointerTest, StuckPointerButtonDuringGrab)
     XAllowEvents(dpy, AsyncPointer, CurrentTime);
     XFlush(dpy);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonUp(1);
 
     ASSERT_EVENT(XDGAButtonEvent, dga_release, dpy, dga_event_base + ButtonRelease);
 
@@ -127,8 +134,9 @@ TEST_F(DGAPointerTest, StuckPointerButtonDuringGrab)
     XDGASetMode(dpy, 0, 0);
     XFlush(dpy);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
+
     ASSERT_EVENT(XButtonEvent, press2, dpy, ButtonPress);
     ASSERT_EVENT(XButtonEvent, release2, dpy, ButtonRelease);
 }
diff --git a/tests/server/grab.cpp b/tests/server/grab.cpp
index d9c5c4e0257e671813a0d765216f274164abb36e..161917b8cc66c930fdf8d5b84e0717d49e76ed15 100644
--- a/tests/server/grab.cpp
+++ b/tests/server/grab.cpp
@@ -37,7 +37,7 @@
 
 #include "xit-event.h"
 #include "xit-server-input-test.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 #include "helpers.h"
 
 
@@ -46,13 +46,14 @@
  * which is later used for the XkbLayout option.
  */
 class PointerGrabTest : public XITServerInputTest,
-                        public DeviceInterface {
+                        public DeviceInputTestInterface {
 public:
     /**
      * Initializes a standard mouse device.
      */
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         xi2_major_minimum = 2;
         xi2_minor_minimum = 1;
@@ -67,15 +68,21 @@ public:
     virtual void SetUpConfigAndLog() {
 
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-kbd--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 TEST_F(PointerGrabTest, ImplicitGrabRawEvents)
@@ -118,7 +125,7 @@ TEST_F(PointerGrabTest, ImplicitGrabRawEvents)
     XSync(dpy, False);
 
     /* Move pointer, make sure we receive raw events */
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(1, 0);
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
                                                            xi2_opcode,
@@ -129,7 +136,7 @@ TEST_F(PointerGrabTest, ImplicitGrabRawEvents)
     ASSERT_TRUE(NoEventPending(dpy));
 
     /* Now press button, make sure sure we still get raw events */
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
+    Dev(0).ButtonDown(1);
 
     /* raw button events come before normal button events */
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
@@ -142,7 +149,7 @@ TEST_F(PointerGrabTest, ImplicitGrabRawEvents)
                                                            xi2_opcode,
                                                            XI_ButtonPress,
                                                            1000));
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(-1, 0);
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
                                                            xi2_opcode,
@@ -203,14 +210,14 @@ TEST_F(PointerGrabTest, DestroyWindowDuringImplicitGrab)
 
     XSync(dpy, True);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
+    Dev(0).ButtonDown(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, ButtonPress, -1, -1));
 
     XDestroyWindow(dpy, win);
     XSync(dpy, False);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonUp(1);
 
     XSync(dpy, False);
     ASSERT_EQ(server.GetState(), xorg::testing::Process::RUNNING);
@@ -242,13 +249,13 @@ TEST_F(PointerGrabTest, DestroyClientDuringImplicitGrab)
 
     XSync(dpy, True);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
+    Dev(0).ButtonDown(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, ButtonPress, -1, -1));
 
     XCloseDisplay(dpy);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonUp(1);
 
     ASSERT_EQ(server.GetState(), xorg::testing::Process::RUNNING);
 }
@@ -280,7 +287,7 @@ TEST_F(PointerGrabTest, ImplicitGrabToActiveGrab)
 
     XSync(dpy, True);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
+    Dev(0).ButtonDown(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, ButtonPress, -1, -1));
 
@@ -288,7 +295,7 @@ TEST_F(PointerGrabTest, ImplicitGrabToActiveGrab)
                 GrabModeAsync, GrabModeAsync, None, None, CurrentTime));
     XSync(dpy, False);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonUp(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, ButtonRelease, -1, -1));
     ASSERT_EQ(server.GetState(), xorg::testing::Process::RUNNING);
@@ -322,7 +329,7 @@ TEST_F(PointerGrabTest, ImplicitGrabToActiveGrabDeactivated)
 
     XSync(dpy, True);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
+    Dev(0).ButtonDown(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, ButtonPress, -1, -1));
 
@@ -333,7 +340,7 @@ TEST_F(PointerGrabTest, ImplicitGrabToActiveGrabDeactivated)
     XUngrabPointer(dpy, CurrentTime);
     XSync(dpy, False);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonUp(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy, ButtonRelease, -1, -1));
     ASSERT_EQ(server.GetState(), xorg::testing::Process::RUNNING);
@@ -360,10 +367,10 @@ TEST_F(PointerGrabTest, AsyncPassiveGrabPressRelease)
                 ButtonPressMask|ButtonReleaseMask,
                 GrabModeAsync, GrabModeAsync, None, None);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     for (int i = 0; i < 2; i++) {
         ASSERT_EVENT(XEvent, press, dpy1, ButtonPress);
@@ -371,10 +378,11 @@ TEST_F(PointerGrabTest, AsyncPassiveGrabPressRelease)
     }
 
     XUngrabButton(dpy1, AnyButton, XIAnyModifier, win);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     for (int i = 0; i < 2; i++) {
         ASSERT_EVENT(XEvent, press, dpy2, ButtonPress);
@@ -385,48 +393,43 @@ TEST_F(PointerGrabTest, AsyncPassiveGrabPressRelease)
     ASSERT_TRUE(NoEventPending(dpy2));
 }
 
-class PointerKeyboardGrabTest : public PointerGrabTest {
+class PointerKeyboardGrabTest : public XITServerInputTest,
+                                public DeviceInputTestInterface {
 public:
-    std::unique_ptr<xorg::testing::evemu::Device> mouse;
-    std::unique_ptr<xorg::testing::evemu::Device> keyboard;
-    std::unique_ptr<xorg::testing::evemu::Device> touch;
+    xorg::testing::inputtest::Device& MouseDev() { return Dev(0); }
+    xorg::testing::inputtest::Device& KeyboardDev() { return Dev(1); }
+    xorg::testing::inputtest::Device& TouchDev() { return Dev(2); }
 
-    virtual void SetUp() {
-      mouse = std::unique_ptr<xorg::testing::evemu::Device>(
-              new xorg::testing::evemu::Device(
-                  RECORDINGS_DIR "mice/PIXART-USB-OPTICAL-MOUSE.desc")
-              );
-
-      keyboard = std::unique_ptr<xorg::testing::evemu::Device>(
-              new xorg::testing::evemu::Device(
-                  RECORDINGS_DIR "keyboards/AT-Translated-Set-2-Keyboard.desc")
-              );
-
-      touch = std::unique_ptr<xorg::testing::evemu::Device>(
-              new xorg::testing::evemu::Device(
-                  RECORDINGS_DIR "tablets/N-Trig-MultiTouch.desc")
-              );
-
-      XITServerInputTest::SetUp();
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+
+        XITServerInputTest::SetUp();
     }
 
-    virtual void SetUpConfigAndLog() {
+    void SetUpConfigAndLog() override {
 
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--mouse--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--mouse--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + mouse->GetDeviceNode() + "\"");
-        config.AddInputSection("evdev", "--keyboard--",
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               MouseDev().GetOptions());
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--keyboard--",
                                "Option \"CoreKeyboard\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + keyboard->GetDeviceNode() + "\"");
-        config.AddInputSection("evdev", "--touch--",
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               KeyboardDev().GetOptions());
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--touch--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + touch->GetDeviceNode() + "\"");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               TouchDev().GetOptions());
         config.WriteConfig();
     }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 TEST_F(PointerKeyboardGrabTest, PointerAsyncKeyboardSyncKeyboardReplay)
@@ -447,10 +450,10 @@ TEST_F(PointerKeyboardGrabTest, PointerAsyncKeyboardSyncKeyboardReplay)
     XGrabButton(dpy, 1, AnyModifier, win, False, ButtonPressMask,
                 GrabModeAsync, GrabModeSync, None, None);
 
-    mouse->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    keyboard->PlayOne(EV_KEY, KEY_A, 1, true);
-    keyboard->PlayOne(EV_KEY, KEY_A, 0, true);
-    mouse->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    MouseDev().ButtonDown(1);
+    KeyboardDev().KeyDown(KEY_A);
+    KeyboardDev().KeyUp(KEY_A);
+    MouseDev().ButtonUp(1);
 
     ASSERT_EVENT(XEvent, press, dpy, ButtonPress);
     ASSERT_EVENT(XEvent, key_press, dpy, KeyPress);
@@ -476,10 +479,10 @@ TEST_F(PointerKeyboardGrabTest, TouchPointerAsyncKeyboardSyncKeyboardReplay)
     XGrabButton(dpy, 1, AnyModifier, win, False, ButtonPressMask,
                 GrabModeAsync, GrabModeSync, None, None);
 
-    touch->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    keyboard->PlayOne(EV_KEY, KEY_A, 1, true);
-    keyboard->PlayOne(EV_KEY, KEY_A, 0, true);
-    touch->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchBegin(100, 200, 0);
+    KeyboardDev().KeyDown(KEY_A);
+    KeyboardDev().KeyUp(KEY_A);
+    TouchDev().TouchEnd(100, 200, 0);
 
     ASSERT_EVENT(XEvent, press, dpy, ButtonPress);
     ASSERT_EVENT(XEvent, key_press, dpy, KeyPress);
@@ -511,10 +514,10 @@ TEST_F(PointerKeyboardGrabTest, TouchPointerAsyncKeyboardSyncKeyboardReplayMulti
     XGrabButton(dpy2, 1, AnyModifier, DefaultRootWindow(dpy2), False,
                 ButtonPressMask, GrabModeAsync, GrabModeSync, None, None);
 
-    touch->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    keyboard->PlayOne(EV_KEY, KEY_A, 1, true);
-    keyboard->PlayOne(EV_KEY, KEY_A, 0, true);
-    touch->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchBegin(100, 200, 0);
+    KeyboardDev().KeyDown(KEY_A);
+    KeyboardDev().KeyUp(KEY_A);
+    TouchDev().TouchEnd(100, 200, 0);
 
     ASSERT_EVENT(XEvent, press, dpy2, ButtonPress);
     ASSERT_EVENT(XEvent, key_press, dpy, KeyPress);
@@ -543,10 +546,10 @@ TEST_F(PointerKeyboardGrabTest, TouchPointerAsyncKeyboardSyncKeyboardReplayOwner
             ButtonPressMask|ButtonReleaseMask,
                 GrabModeAsync, GrabModeSync, None, None);
 
-    touch->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    keyboard->PlayOne(EV_KEY, KEY_A, 1, true);
-    keyboard->PlayOne(EV_KEY, KEY_A, 0, true);
-    touch->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchBegin(100, 200, 0);
+    KeyboardDev().KeyDown(KEY_A);
+    KeyboardDev().KeyUp(KEY_A);
+    TouchDev().TouchEnd(100, 200, 0);
 
     ASSERT_EVENT(XEvent, press, dpy, ButtonPress);
     ASSERT_EVENT(XEvent, release, dpy, ButtonRelease);
@@ -560,7 +563,7 @@ TEST_F(PointerKeyboardGrabTest, TouchPointerAsyncKeyboardSyncKeyboardReplayOwner
  * @tparam AsyncPointer, SyncPointer, ReplayPointer
  */
 class PointerGrabTestAllowEvents : public PointerGrabTest,
-                                        public ::testing::WithParamInterface<int> {
+                                   public ::testing::WithParamInterface<int> {
 };
 
 TEST_P(PointerGrabTestAllowEvents, AllowEventsDoubleClick)
@@ -590,10 +593,10 @@ TEST_P(PointerGrabTestAllowEvents, AllowEventsDoubleClick)
                 ButtonPressMask|ButtonReleaseMask,
                 GrabModeSync, GrabModeAsync, None, None);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     for (int i = 0; i < 2; i++) {
         ASSERT_EVENT(XEvent, press, dpy1, ButtonPress);
@@ -684,7 +687,7 @@ TEST_P(PointerSingleGrabTypeTest, OverwriteGrab)
     }
     ASSERT_EQ(rc, Success);
 
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(-1, 0);
 
     switch(grab_type) {
         case GRABTYPE_CORE:
@@ -721,7 +724,7 @@ TEST_P(PointerSingleGrabTypeTest, OverwriteGrab)
             break;
     }
 
-    dev->PlayOne(EV_REL, REL_X, -1, true);
+    Dev(0).RelMotion(-1, 0);
 
     ASSERT_TRUE(NoEventPending(dpy));
 }
@@ -826,13 +829,14 @@ INSTANTIATE_TEST_CASE_P(, PointerGrabTypeTest,
             ::testing::Values(GRABTYPE_CORE, GRABTYPE_XI1, GRABTYPE_XI2)));
 
 class TouchGrabTest : public XITServerInputTest,
-                      public DeviceInterface {
+                      public DeviceInputTestInterface {
 public:
-    /**
-     * Initializes a standard mouse device.
-     */
-    virtual void SetUp() {
-        SetDevice("tablets/N-Trig-MultiTouch.desc");
+    xorg::testing::inputtest::Device& TouchDev() { return Dev(0); }
+    xorg::testing::inputtest::Device& KeyboardDev() { return Dev(1); }
+
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         xi2_major_minimum = 2;
         xi2_minor_minimum = 2;
@@ -844,18 +848,24 @@ public:
      * Sets up an xorg.conf for a single evdev CoreKeyboard device based on
      * the evemu device. The input from GetParam() is used as XkbLayout.
      */
-    virtual void SetUpConfigAndLog() {
+    void SetUpConfigAndLog() override {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               TouchDev().GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--kbd-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               KeyboardDev().GetOptions());
         config.WriteConfig();
     }
 
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
+
     /**
      * Return a new synchronized client given our default server connection.
      */
@@ -910,31 +920,6 @@ public:
         delete[] mask.mask;
         XSync(dpy, False);
     }
-
-    virtual void TouchBegin(int x, int y) {
-        dev->PlayOne(EV_KEY, BTN_TOUCH, 1);
-        TouchUpdate(x, y);
-    }
-
-    virtual void TouchUpdate(int x, int y, bool sync = true) {
-        dev->PlayOne(EV_ABS, ABS_X, x);
-        dev->PlayOne(EV_ABS, ABS_Y, y);
-        dev->PlayOne(EV_ABS, ABS_MT_POSITION_X, x);
-        dev->PlayOne(EV_ABS, ABS_MT_POSITION_Y, y);
-        /* same values as the recordings file */
-        dev->PlayOne(EV_ABS, ABS_MT_ORIENTATION, 0);
-        dev->PlayOne(EV_ABS, ABS_MT_TOUCH_MAJOR, 468);
-        dev->PlayOne(EV_ABS, ABS_MT_TOUCH_MINOR, 306);
-        dev->PlayOne(EV_SYN, SYN_MT_REPORT, 0);
-        if (sync)
-            dev->PlayOne(EV_SYN, SYN_REPORT, 0);
-    }
-
-    virtual void TouchEnd() {
-        dev->PlayOne(EV_KEY, BTN_TOUCH, 0);
-        dev->PlayOne(EV_SYN, SYN_REPORT, 0);
-    }
-
 };
 
 TEST_F(TouchGrabTest, ActivePointerGrabOverPointerSelection)
@@ -955,24 +940,26 @@ TEST_F(TouchGrabTest, ActivePointerGrabOverPointerSelection)
                     -1);
     GrabPointer(dpy2, VIRTUAL_CORE_POINTER_ID, win);
 
-    TouchBegin(200, 200);
-    TouchUpdate(282, 282);
-    TouchEnd();
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchUpdate(282, 282, 0);
+    TouchDev().TouchEnd(282, 282, 0);
 
+    ASSERT_EVENT(XIDeviceEvent, motion11, dpy2, GenericEvent, xi2_opcode, XI_Motion);
     ASSERT_EVENT(XIDeviceEvent, press, dpy2, GenericEvent, xi2_opcode, XI_ButtonPress);
-    ASSERT_EVENT(XIDeviceEvent, motion, dpy2, GenericEvent, xi2_opcode, XI_Motion);
-    ASSERT_EVENT(XIDeviceEvent, motion1, dpy2, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EVENT(XIDeviceEvent, motion12, dpy2, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EVENT(XIDeviceEvent, motion13, dpy2, GenericEvent, xi2_opcode, XI_Motion);
     ASSERT_EVENT(XIDeviceEvent, release, dpy2, GenericEvent, xi2_opcode, XI_ButtonRelease);
 
     ASSERT_TRUE(NoEventPending(dpy2));
 
-    TouchBegin(210, 210);
-    TouchUpdate(292, 292);
-    TouchEnd();
+    TouchDev().TouchBegin(210, 210, 0);
+    TouchDev().TouchUpdate(292, 292, 0);
+    TouchDev().TouchEnd(292, 292, 0);
 
+    ASSERT_EVENT(XIDeviceEvent, motion21, dpy2, GenericEvent, xi2_opcode, XI_Motion);
     ASSERT_EVENT(XIDeviceEvent, press2, dpy2, GenericEvent, xi2_opcode, XI_ButtonPress);
-    ASSERT_EVENT(XIDeviceEvent, motion2, dpy2, GenericEvent, xi2_opcode, XI_Motion);
-    ASSERT_EVENT(XIDeviceEvent, motion3, dpy2, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EVENT(XIDeviceEvent, motion22, dpy2, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EVENT(XIDeviceEvent, motion23, dpy2, GenericEvent, xi2_opcode, XI_Motion);
     ASSERT_EVENT(XIDeviceEvent, release2, dpy2, GenericEvent, xi2_opcode, XI_ButtonRelease);
 
     ASSERT_TRUE(NoEventPending(dpy2));
@@ -1014,8 +1001,8 @@ TEST_F(TouchGrabTest, PassiveTouchGrabPassedToTouchClient)
     XISelectEvents(dpy2, win, &mask, 1);
     delete[] mask.mask;
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchEnd(200, 200, 0);
 
     ASSERT_EVENT(XIDeviceEvent, tbegin, dpy1, GenericEvent, xi2_opcode, XI_TouchBegin);
     ASSERT_EVENT(XIDeviceEvent, tend, dpy1, GenericEvent, xi2_opcode, XI_TouchEnd);
@@ -1027,7 +1014,7 @@ TEST_F(TouchGrabTest, PassiveTouchGrabPassedToTouchClient)
     ASSERT_TRUE(NoEventPending(dpy1));
 
     /* use a third client for checking pointer state, since a XI2.2 client
-     * won't see emulated touch state */
+     * won't see inputtest touch state */
     ::Display *dpy3 = XOpenDisplay(server.GetDisplayString().c_str());
     XSynchronize(dpy3, True);
     Window child;
@@ -1082,8 +1069,8 @@ TEST_F(TouchGrabTest, TouchGrabPassedToCoreGrab)
                 GrabModeAsync, GrabModeAsync, None, None);
 
     for (int i = 0; i < 10; i++) {
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+        TouchDev().TouchBegin(200, 200, 0);
+        TouchDev().TouchEnd(200, 200, 0);
 
         ASSERT_EVENT(XIDeviceEvent, tbegin, dpy1, GenericEvent, xi2_opcode, XI_TouchBegin);
         ASSERT_EVENT(XIDeviceEvent, tend, dpy1, GenericEvent, xi2_opcode, XI_TouchEnd);
@@ -1130,8 +1117,8 @@ TEST_F(TouchGrabTest, TouchGrabPassedToTouch)
     delete[] mask.mask;
 
     for (int i = 0; i < 10; i++) {
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+        TouchDev().TouchBegin(200, 200, 0);
+        TouchDev().TouchEnd(200, 200, 0);
 
         ASSERT_EVENT(XIDeviceEvent, tbegin, dpy1, GenericEvent, xi2_opcode, XI_TouchBegin);
         ASSERT_EVENT(XIDeviceEvent, tend, dpy1, GenericEvent, xi2_opcode, XI_TouchEnd);
@@ -1196,7 +1183,7 @@ TEST_F(TouchGrabTest, TouchGrabPassedToTouchEarlyAccept)
                                         subwin, False, &mask, 1, &mods));
     delete[] mask.mask;
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     /* C1 is owner, but all three get begin event */
     ASSERT_EVENT(XIDeviceEvent, tbegin1, dpy1, GenericEvent, xi2_opcode, XI_TouchBegin);
@@ -1215,7 +1202,8 @@ TEST_F(TouchGrabTest, TouchGrabPassedToTouchEarlyAccept)
     ASSERT_EVENT(XIDeviceEvent, towner2, dpy2, GenericEvent, xi2_opcode, XI_TouchOwnership);
 
     /* Physicall end touch */
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
+
     ASSERT_EVENT(XIDeviceEvent, tend2, dpy2, GenericEvent, xi2_opcode, XI_TouchEnd);
     ASSERT_TRUE(NoEventPending(dpy2));
 
@@ -1239,12 +1227,12 @@ TEST_F(TouchGrabTest, GrabMultipleTouchpoints)
 
     GrabDevice(dpy, deviceid, win);
 
-    /* ntrig has no slots, so the second update actually creates a new point */
-    TouchBegin(200, 200);
-    TouchUpdate(250, 250, false);
-    TouchUpdate(2500, 2500, true);
-    TouchUpdate(2700, 2700, true);
-    TouchEnd();
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchUpdate(250, 250, 0);
+    TouchDev().TouchBegin(2500, 2500, 1);
+    TouchDev().TouchUpdate(2600, 2600, 1);
+    TouchDev().TouchEnd(250, 250, 0);
+    TouchDev().TouchEnd(2700, 2700, 1);
 
     EXPECT_EVENT(XIDeviceEvent, tbegin1, dpy, GenericEvent, xi2_opcode, XI_TouchBegin);
     EXPECT_EVENT(XIDeviceEvent, tupdate1, dpy, GenericEvent, xi2_opcode, XI_TouchUpdate);
@@ -1257,7 +1245,8 @@ TEST_F(TouchGrabTest, GrabMultipleTouchpoints)
 
 class TouchGrabTestOnLegacyClient : public TouchGrabTest {
     virtual void SetUp() {
-        SetDevice("tablets/N-Trig-MultiTouch.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         xi2_major_minimum = 2;
         xi2_minor_minimum = 0;
@@ -1291,25 +1280,30 @@ TEST_F(TouchGrabTestOnLegacyClient, ActivePointerGrabUngrabDuringTouch)
                     XI_Motion,
                     -1);
 
-    TouchBegin(200, 200);
-    TouchUpdate(202, 202);
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchUpdate(202, 202, 0);
 
-    EXPECT_EVENT(XIDeviceEvent, m1, dpy, GenericEvent, xi2_opcode, XI_Motion);
+    EXPECT_EVENT(XIDeviceEvent, m11, dpy, GenericEvent, xi2_opcode, XI_Motion);
     EXPECT_EVENT(XIDeviceEvent, p1, dpy, GenericEvent, xi2_opcode, XI_ButtonPress);
+    EXPECT_EVENT(XIDeviceEvent, m12, dpy, GenericEvent, xi2_opcode, XI_Motion);
     ASSERT_TRUE(NoEventPending(dpy));
 
     GrabPointer(dpy, VIRTUAL_CORE_POINTER_ID, win);
-    TouchEnd();
 
+    TouchDev().TouchEnd(202, 202, 0);
+
+    EXPECT_EVENT(XIDeviceEvent, m13, dpy, GenericEvent, xi2_opcode, XI_Motion);
     EXPECT_EVENT(XIDeviceEvent, r1, dpy, GenericEvent, xi2_opcode, XI_ButtonRelease);
 
-    TouchBegin(200, 200);
-    TouchUpdate(202, 202);
-    EXPECT_EVENT(XIDeviceEvent, m2, dpy, GenericEvent, xi2_opcode, XI_Motion);
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchUpdate(202, 202, 0);
+
+    EXPECT_EVENT(XIDeviceEvent, m21, dpy, GenericEvent, xi2_opcode, XI_Motion);
     EXPECT_EVENT(XIDeviceEvent, p2, dpy, GenericEvent, xi2_opcode, XI_ButtonPress);
+    EXPECT_EVENT(XIDeviceEvent, m22, dpy, GenericEvent, xi2_opcode, XI_Motion);
     XIUngrabDevice(dpy, VIRTUAL_CORE_POINTER_ID, CurrentTime);
 
-    TouchEnd();
+    TouchDev().TouchEnd(202, 202, 0);
 
     ASSERT_TRUE(NoEventPending(dpy));
 }
@@ -1355,10 +1349,12 @@ TEST_F(TouchGrabTestOnLegacyClient, ActivePointerGrabOverPointerSelection)
     XISelectEvents(dpy, win, mask, 2);
     GrabPointer(dpy, VIRTUAL_CORE_POINTER_ID, win);
 
-    TouchBegin(200, 200);
-    TouchUpdate(202, 202);
-    TouchEnd();
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchUpdate(202, 202, 0);
+    TouchDev().TouchEnd(202, 202, 0);
 
+    ASSERT_EVENT(XIDeviceEvent, motion1_dev_1, dpy, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EQ(motion1_dev_1->deviceid, deviceid);
     ASSERT_EVENT(XIDeviceEvent, press_dev_1, dpy, GenericEvent, xi2_opcode, XI_ButtonPress);
     ASSERT_EQ(press_dev_1->deviceid, deviceid);
 
@@ -1367,13 +1363,18 @@ TEST_F(TouchGrabTestOnLegacyClient, ActivePointerGrabOverPointerSelection)
     ASSERT_EVENT(XIDeviceEvent, press, dpy, GenericEvent, xi2_opcode, XI_ButtonPress);
     ASSERT_EQ(press->deviceid, VIRTUAL_CORE_POINTER_ID);
 
-    ASSERT_EVENT(XIDeviceEvent, motion_dev_1, dpy, GenericEvent, xi2_opcode, XI_Motion);
-    ASSERT_EQ(motion_dev_1->deviceid, deviceid);
+    ASSERT_EVENT(XIDeviceEvent, motion2_dev_1, dpy, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EQ(motion2_dev_1->deviceid, deviceid);
+    ASSERT_EVENT(XIDeviceEvent, motion2, dpy, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EQ(motion2->deviceid, VIRTUAL_CORE_POINTER_ID);
+
+    ASSERT_EVENT(XIDeviceEvent, motion3_dev_1, dpy, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EQ(motion3_dev_1->deviceid, deviceid);
     ASSERT_EVENT(XIDeviceEvent, release_dev_1, dpy, GenericEvent, xi2_opcode, XI_ButtonRelease);
     ASSERT_EQ(release_dev_1->deviceid, deviceid);
 
-    ASSERT_EVENT(XIDeviceEvent, motion2, dpy, GenericEvent, xi2_opcode, XI_Motion);
-    ASSERT_EQ(motion2->deviceid, VIRTUAL_CORE_POINTER_ID);
+    ASSERT_EVENT(XIDeviceEvent, motion3, dpy, GenericEvent, xi2_opcode, XI_Motion);
+    ASSERT_EQ(motion3->deviceid, VIRTUAL_CORE_POINTER_ID);
     ASSERT_EVENT(XIDeviceEvent, release, dpy, GenericEvent, xi2_opcode, XI_ButtonRelease);
     ASSERT_EQ(release->deviceid, VIRTUAL_CORE_POINTER_ID);
 
@@ -1385,7 +1386,8 @@ class TouchUngrabTest : public TouchGrabTest,
                         public ::testing::WithParamInterface<enum GrabType>
 {
     virtual void SetUp() {
-        SetDevice("tablets/N-Trig-MultiTouch.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         xi2_major_minimum = 2;
         switch(GetParam()) {
@@ -1451,7 +1453,7 @@ TEST_P(TouchUngrabTest, UngrabButtonDuringTouch)
             break;
     }
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     switch (grab_type) {
         case GRABTYPE_CORE:
@@ -1477,7 +1479,7 @@ TEST_P(TouchUngrabTest, UngrabButtonDuringTouch)
     }
 
     ASSERT_TRUE(NoEventPending(dpy));
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_update.events");
+    TouchDev().TouchUpdate(250, 250, 0);
 
     switch (grab_type) {
         case GRABTYPE_CORE:
@@ -1500,7 +1502,7 @@ TEST_P(TouchUngrabTest, UngrabButtonDuringTouch)
     }
 
     ASSERT_TRUE(NoEventPending(dpy));
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     switch (grab_type) {
         case GRABTYPE_CORE:
@@ -1592,9 +1594,9 @@ TEST_P(TouchGrabTestAllowSome, TouchGrabPassedToPassivePassedToRegular)
     XSelectInput(dpy3, win, ButtonPressMask|ButtonReleaseMask);
 
     for (int i = 0; i < 2; i++) {
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_update.events");
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+        TouchDev().TouchBegin(200, 200, 0);
+        TouchDev().TouchUpdate(250, 250, 0);
+        TouchDev().TouchEnd(250, 250, 0);
     }
 
     for (int i = 0; i < 2; i++) {
@@ -1660,7 +1662,7 @@ TEST_P(TouchGrabTestMultipleModes, SingleTouchGrabListenerAcceptRejectBeforeTouc
                                         root, False, &mask, 1, &mods));
     delete[] mask.mask;
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     ASSERT_EVENT(XIDeviceEvent, tbegin, dpy, GenericEvent, xi2_opcode, XI_TouchBegin);
     XIAllowTouchEvents(dpy, tbegin->deviceid, tbegin->detail, root, mode);
@@ -1671,7 +1673,7 @@ TEST_P(TouchGrabTestMultipleModes, SingleTouchGrabListenerAcceptRejectBeforeTouc
         ASSERT_EVENT(XIDeviceEvent, tend, dpy, GenericEvent, xi2_opcode, XI_TouchEnd);
     }
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     if (mode == XIAcceptTouch) {
         ASSERT_EVENT(XIDeviceEvent, tend, dpy, GenericEvent, xi2_opcode, XI_TouchEnd);
@@ -1712,8 +1714,8 @@ TEST_P(TouchGrabTestMultipleModes, ActiveAndPassiveGrab)
     ASSERT_EQ(XIGrabTouchBegin(Display(), deviceid, win, False, &mask, 1, &modifier), Success);
     XIGrabDevice(Display(), deviceid, win, CurrentTime, None, GrabModeAsync, GrabModeAsync, False, &mask);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchEnd(250, 250, 0);
 
     XSync(Display(), False);
 
@@ -1805,8 +1807,8 @@ TEST_P(TouchGrabTestMultipleTaps, PassiveGrabPointerEmulationMultipleTouchesFast
     /* for this test to succeed, the server mustn't start processing until
        the last touch event physically ends, so no usleep here*/
     for (int i = 0; i < repeats; i++) {
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+        TouchDev().TouchBegin(200, 200, 0);
+        TouchDev().TouchEnd(250, 250, 0);
     }
 
     XSync(dpy1, False);
@@ -1883,8 +1885,8 @@ TEST_P(TouchGrabTestMultipleTaps, PassiveGrabPointerRelease)
     /* for this test to succeed, the server mustn't start processing until
        the last touch event physically ends, so no usleep here*/
     for (int i = 0; i < repeats; i++) {
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-        dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+        TouchDev().TouchBegin(200, 200, 0);
+        TouchDev().TouchEnd(250, 250, 0);
     }
 
     XSync(dpy1, False);
@@ -1991,7 +1993,7 @@ TEST_F(TouchOwnershipTest, OwnershipAfterRejectTouch)
     win[NCLIENTS-1] = w;
     SelectTouchOnWindow(dpys[NCLIENTS-1], w, true);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     int touchid = -1;
 
@@ -2023,7 +2025,7 @@ TEST_F(TouchOwnershipTest, OwnershipAfterRejectTouch)
         ASSERT_EQ(oe->touchid, (unsigned int)touchid);
     }
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     int last_owner = NCLIENTS-1;
     ASSERT_EVENT(XIDeviceEvent, tend, dpys[last_owner], GenericEvent, xi2_opcode, XI_TouchEnd);
@@ -2054,7 +2056,7 @@ TEST_F(TouchOwnershipTest, NoOwnershipAfterAcceptTouch)
     Window win = CreateWindow(dpy2, DefaultRootWindow(dpy));
     SelectTouchOnWindow(dpy2, win, true);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     /* Expect touch begin to A */
     ASSERT_EVENT(XIDeviceEvent, A_begin, dpy, GenericEvent, xi2_opcode, XI_TouchBegin);
@@ -2077,7 +2079,7 @@ TEST_F(TouchOwnershipTest, NoOwnershipAfterAcceptTouch)
     ASSERT_EVENT(XIDeviceEvent, B_end, dpy2, GenericEvent, xi2_opcode, XI_TouchEnd);
     ASSERT_EQ(B_end->detail, touchid);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     ASSERT_EVENT(XIDeviceEvent, A_end, dpy, GenericEvent, xi2_opcode, XI_TouchEnd);
     ASSERT_EQ(A_end->detail, touchid);
@@ -2105,7 +2107,7 @@ TEST_F(TouchOwnershipTest, ActiveGrabOwnershipAcceptTouch)
     /* Client A grabs the device */
     GrabDevice(dpy, VIRTUAL_CORE_POINTER_ID, DefaultRootWindow(dpy));
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     /* Expect touch begin to A */
     ASSERT_EVENT(XIDeviceEvent, A_begin, dpy, GenericEvent, xi2_opcode, XI_TouchBegin);
@@ -2127,7 +2129,7 @@ TEST_F(TouchOwnershipTest, ActiveGrabOwnershipAcceptTouch)
     ASSERT_EVENT(XIDeviceEvent, B_end, dpy2, GenericEvent, xi2_opcode, XI_TouchEnd);
     ASSERT_EQ(B_end->detail, touchid);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     ASSERT_EVENT(XIDeviceEvent, A_end, dpy, GenericEvent, xi2_opcode, XI_TouchEnd);
     ASSERT_EQ(A_end->detail, touchid);
@@ -2155,7 +2157,7 @@ TEST_F(TouchOwnershipTest, ActiveGrabOwnershipRejectTouch)
     /* Client A grabs the device */
     GrabDevice(dpy, VIRTUAL_CORE_POINTER_ID, DefaultRootWindow(dpy));
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     /* Expect touch begin to A */
     ASSERT_EVENT(XIDeviceEvent, A_begin, dpy, GenericEvent, xi2_opcode, XI_TouchBegin);
@@ -2181,7 +2183,7 @@ TEST_F(TouchOwnershipTest, ActiveGrabOwnershipRejectTouch)
     ASSERT_EVENT(XITouchOwnershipEvent, oe, dpy2, GenericEvent, xi2_opcode, XI_TouchOwnership);
     ASSERT_EQ(oe->touchid, (unsigned int)touchid);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     ASSERT_EVENT(XIDeviceEvent, B_end, dpy2, GenericEvent, xi2_opcode, XI_TouchEnd);
 
@@ -2208,7 +2210,7 @@ TEST_F(TouchOwnershipTest, ActiveGrabOwnershipUngrabDevice)
     /* Client A grabs the device */
     GrabDevice(dpy, VIRTUAL_CORE_POINTER_ID, DefaultRootWindow(dpy));
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     /* Expect touch begin to A */
     ASSERT_EVENT(XIDeviceEvent, A_begin, dpy, GenericEvent, xi2_opcode, XI_TouchBegin);
@@ -2232,7 +2234,7 @@ TEST_F(TouchOwnershipTest, ActiveGrabOwnershipUngrabDevice)
     ASSERT_EVENT(XITouchOwnershipEvent, oe, dpy2, GenericEvent, xi2_opcode, XI_TouchOwnership);
     ASSERT_EQ(oe->touchid, (unsigned int)touchid);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     ASSERT_EVENT(XIDeviceEvent, B_end, dpy2, GenericEvent, xi2_opcode, XI_TouchEnd);
     ASSERT_EQ(B_end->detail, touchid);
@@ -2260,7 +2262,7 @@ TEST_F(TouchOwnershipTest, ActivePointerGrabForWholeTouch)
     /* Client A grabs the device */
     GrabPointer(dpy, VIRTUAL_CORE_POINTER_ID, DefaultRootWindow(dpy));
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     ASSERT_EVENT(XIDeviceEvent, A_btnpress, dpy, GenericEvent, xi2_opcode, XI_ButtonPress);
 
@@ -2269,7 +2271,7 @@ TEST_F(TouchOwnershipTest, ActivePointerGrabForWholeTouch)
     /* No ownership event on the wire */
     ASSERT_TRUE(NoEventPending(dpy2));
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     ASSERT_EVENT(XIDeviceEvent, A_btnrelease, dpy, GenericEvent, xi2_opcode, XI_ButtonRelease);
 
@@ -2304,7 +2306,7 @@ TEST_F(TouchOwnershipTest, ActivePointerUngrabDuringTouch)
     /* Client A grabs the device */
     GrabPointer(dpy, VIRTUAL_CORE_POINTER_ID, DefaultRootWindow(dpy));
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(200, 200, 0);
 
     ASSERT_EVENT(XIDeviceEvent, A_btnpress, dpy, GenericEvent, xi2_opcode, XI_ButtonPress);
 
@@ -2318,7 +2320,7 @@ TEST_F(TouchOwnershipTest, ActivePointerUngrabDuringTouch)
 
     ASSERT_EVENT(XIDeviceEvent, B_end, dpy2, GenericEvent, xi2_opcode, XI_TouchEnd);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(250, 250, 0);
 
     ASSERT_TRUE(NoEventPending(dpy));
     ASSERT_TRUE(NoEventPending(dpy2));
@@ -2326,37 +2328,38 @@ TEST_F(TouchOwnershipTest, ActivePointerUngrabDuringTouch)
 
 
 class GrabModeTest : public XITServerInputTest,
-                     public ::testing::WithParamInterface<int>
+                     public ::testing::WithParamInterface<int>,
+                     public DeviceInputTestInterface
 {
 public:
-    std::unique_ptr<xorg::testing::evemu::Device> ptr;
-    std::unique_ptr<xorg::testing::evemu::Device> kbd;
+    xorg::testing::inputtest::Device& PointerDev() { return Dev(0); }
+    xorg::testing::inputtest::Device& KeyboardDev() { return Dev(1); }
 
-    virtual void SetUp() {
-        ptr = std::unique_ptr<xorg::testing::evemu::Device>(
-               new xorg::testing::evemu::Device(
-                   RECORDINGS_DIR "mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc"
-               ));
-        kbd = std::unique_ptr<xorg::testing::evemu::Device>(
-               new xorg::testing::evemu::Device(
-                   RECORDINGS_DIR "keyboards/AT-Translated-Set-2-Keyboard.desc"
-               ));
+
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         XITServerInputTest::SetUp();
     }
 
-    virtual void SetUpConfigAndLog() {
+    void SetUpConfigAndLog() override {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--pointer--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--pointer--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + ptr->GetDeviceNode() + "\"");
-        config.AddInputSection("evdev", "--keyboard--",
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               PointerDev().GetOptions());
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--keyboard--",
                                "Option \"CoreKeyboard\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + kbd->GetDeviceNode() + "\"");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               KeyboardDev().GetOptions());
         config.WriteConfig();
     }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 TEST_P(GrabModeTest, PointerSyncKeyboardAsync)
@@ -2382,11 +2385,11 @@ TEST_P(GrabModeTest, PointerSyncKeyboardAsync)
     XIGrabDevice(dpy, deviceid, DefaultRootWindow(dpy),
                  CurrentTime, None, GrabModeSync, GrabModeAsync, False, &mask);
 
-    ptr->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    ptr->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    PointerDev().ButtonDown(1);
+    PointerDev().ButtonUp(1);
 
-    kbd->PlayOne(EV_KEY, KEY_A, 1, true);
-    kbd->PlayOne(EV_KEY, KEY_A, 0, true);
+    KeyboardDev().KeyDown(KEY_A);
+    KeyboardDev().KeyUp(KEY_A);
 
     /* one device is frozen, we expect no events */
     if (deviceid == VIRTUAL_CORE_POINTER_ID) {
diff --git a/tests/server/misc.cpp b/tests/server/misc.cpp
index daaa56718c3eb2b18b2f7afb820f793fb46aa7bd..5f36b2919fcb5980abd49682f231b26a9f63d8db 100644
--- a/tests/server/misc.cpp
+++ b/tests/server/misc.cpp
@@ -36,19 +36,20 @@
 
 #include "xit-server-input-test.h"
 #include "xit-event.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 #include "helpers.h"
 
 using namespace xorg::testing;
 
 class EventQueueTest : public XITServerInputTest,
-                       public DeviceInterface {
+                       public DeviceInputTestInterface {
 public:
     /**
      * Initializes a standard mouse device.
      */
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XITServerInputTest::SetUp();
     }
 
@@ -58,15 +59,21 @@ public:
      */
     virtual void SetUpConfigAndLog() {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--kbd-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 TEST_F(EventQueueTest, mieqOverflow)
@@ -75,7 +82,7 @@ TEST_F(EventQueueTest, mieqOverflow)
                   "Search the server log for the error message.\n");
 
     for (int i = 0; i < 2048; i++)
-        dev->PlayOne(EV_REL, REL_X, -1, true);
+        Dev(0).RelMotion(-1, 0);
     XSync(Display(), False);
     ASSERT_EQ(server.GetState(), xorg::testing::Process::RUNNING);
 
@@ -141,13 +148,14 @@ TEST(MiscServerTest, DoubleSegfault)
 
 #if HAVE_XSCREENSAVER
 class ScreenSaverTest : public XITServerInputTest,
-                        public DeviceInterface {
+                        public DeviceInputTestInterface {
 public:
     /**
      * Initializes a standard mouse device.
      */
-    virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XITServerInputTest::SetUp();
 
         ASSERT_TRUE(XScreenSaverQueryExtension(Display(), &screensaver_opcode, &screensaver_error_base));
@@ -155,20 +163,26 @@ public:
 
     /**
      * Sets up an xorg.conf for a single evdev CoreKeyboard device based on
-     * the evemu device. The input from GetParam() is used as XkbLayout.
+     * the test device. The input from GetParam() is used as XkbLayout.
      */
-    virtual void SetUpConfigAndLog() {
+    void SetUpConfigAndLog() override {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-kbd--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
 
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
+
     int screensaver_opcode;
     int screensaver_error_base;
 };
@@ -272,25 +286,32 @@ class XSyncTest : public XITServerInputTest {
 };
 
 class IdletimerTest : public XSyncTest,
-                      public DeviceInterface {
+                      public DeviceInputTestInterface {
 public:
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XSyncTest::SetUp();
     }
 
     virtual void SetUpConfigAndLog() {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-kbd--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
 
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
+
     virtual XSyncCounter GetIdletimeCounter(::Display *dpy) {
         int ncounters;
         XSyncSystemCounter *counters;
@@ -323,7 +344,7 @@ public:
         XEvent ev;
         XSelectInput(dpy, DefaultRootWindow(dpy), PointerMotionMask);
         while (!XCheckMaskEvent(dpy, PointerMotionMask, &ev)) {
-            dev->PlayOne(EV_REL, REL_X, 10, true);
+            Dev(0).RelMotion(10, 0);
             XSync(dpy, False);
             usleep(10000);
         }
@@ -488,11 +509,11 @@ TEST_F(IdletimerTest, NegativeTransition)
     neg_alarm = SetAbsoluteAlarm(dpy, idlecounter, threshold, XSyncNegativeTransition);
     ASSERT_GT(neg_alarm, (XSyncAlarm)None);
 
-    dev->PlayOne(EV_REL, REL_X, 10, true);
+    Dev(0).RelMotion(10, 0);
     WaitForEvent(dpy);
     usleep(threshold * 1200);
 
-    dev->PlayOne(EV_REL, REL_X, 10, true);
+    Dev(0).RelMotion(10, 0);
     WaitForEvent(dpy);
 
     ASSERT_EVENT(XSyncAlarmNotifyEvent, ev1, dpy, sync_event + XSyncAlarmNotify);
@@ -574,11 +595,11 @@ TEST_F(IdletimerTest, NegativeTransitionToZero)
     neg_alarm = SetAbsoluteAlarm(dpy, idlecounter, threshold, XSyncNegativeTransition);
     ASSERT_GT(neg_alarm, (XSyncAlarm)None);
 
-    dev->PlayOne(EV_REL, REL_X, 10, true);
+    Dev(0).RelMotion(10, 0);
     WaitForEvent(dpy);
     usleep(10000);
 
-    dev->PlayOne(EV_REL, REL_X, 10, true);
+    Dev(0).RelMotion(10, 0);
     WaitForEvent(dpy);
 
     ASSERT_EVENT(XSyncAlarmNotifyEvent, ev1, dpy, sync_event + XSyncAlarmNotify);
diff --git a/tests/server/multihead.cpp b/tests/server/multihead.cpp
index de7cce87d1da458c6e559edf0144978703cd5497..53622bf38310634afbdf28d012fb56ffabafbf36 100644
--- a/tests/server/multihead.cpp
+++ b/tests/server/multihead.cpp
@@ -40,22 +40,29 @@
 #include "xit-server-input-test.h"
 #include "xit-event.h"
 #include "helpers.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 
 using namespace xorg::testing;
 
-class MultiheadTest : public XITServerInputTest {
+class MultiheadTest : public XITServerInputTest,
+                      public DeviceInputTestInterface {
 public:
-    virtual void SetUpConfigAndLog() {
+    void SetUpConfigAndLog() override {
         config.SetAutoAddDevices(true);
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
+                               "Option \"CorePointer\" \"on\"\n"
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--keyboard-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
+        config.AddServerLayoutOption("    Screen         0 \"Screen0\"");
+        config.AddServerLayoutOption(std::string() +
+            "    Screen         1 \"Screen1\" " + (left_of ? "LeftOf" : "RightOf") + " \"Screen0\"");
+        config.AddServerLayoutOption(std::string() +
+            "	Option         \"Xinerama\" \"" +  (xinerama ? "on" : "off") +"\"");
         config.AppendRawConfig(std::string() +
-            "Section \"ServerLayout\"\n"
-            "	Identifier     \"X.org Configured\"\n"
-            "	Screen         0 \"Screen0\"\n"
-            "	Screen         1 \"Screen1\" " + (left_of ? "LeftOf" : "RightOf") + " \"Screen0\"\n"
-            "	Option         \"Xinerama\" \"" +  (xinerama ? "on" : "off") +"\"\n"
-            "EndSection\n"
-            "\n"
             "Section \"Device\"\n"
             "	Identifier  \"Card0\"\n"
             "	Driver      \"dummy\"\n"
@@ -79,20 +86,25 @@ public:
     }
 
     virtual void SetUp() {
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XITServerInputTest::SetUp();
     }
 
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
+
 protected:
     bool xinerama;
     bool left_of;
 };
 
 class ZaphodTest : public MultiheadTest,
-                   public DeviceInterface,
                    public ::testing::WithParamInterface<bool> {
 public:
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE.desc");
         xinerama = false;
         left_of = GetParam();
         MultiheadTest::SetUp();
@@ -130,21 +142,14 @@ public:
 
     void MoveUntilMotionEvent(::Display *dpy, int direction)
     {
-        int limit = 0;
-        while (!XPending(dpy)) {
-            dev->PlayOne(EV_REL, REL_X, direction * 3, true);
-            XSync(dpy, False);
-            if (limit++ > 50) {
-                ADD_FAILURE() << "Expected events after pointer move";
-                return;
-            }
-        }
+        Dev(0).RelMotion(direction * 30, 0);
+        XSync(dpy, False);
     }
 
     void FlushMotionEvents(::Display *dpy, int direction)
     {
         int limit = 0;
-        dev->PlayOne(EV_REL, REL_X, direction * 3, true);
+        Dev(0).RelMotion(direction * 30, 0);
         XSync(dpy, False);
         while (XPending(dpy)) {
             XEvent ev;
@@ -198,7 +203,7 @@ public:
                         break;
                 }
             }
-            if (limit++ > 30) {
+            if (limit++ > 300) {
                 ADD_FAILURE() << "Expected to hit the screen edge\n";
                 return false;
             }
@@ -351,20 +356,20 @@ TEST_P(ZaphodTest, ScreenCrossingButtons)
     XSelectInput(ldpy, lwin, EnterWindowMask|LeaveWindowMask|ButtonPressMask|ButtonReleaseMask);
     XSelectInput(rdpy, rwin, EnterWindowMask|LeaveWindowMask|ButtonPressMask|ButtonReleaseMask);
 
-    dev->PlayOne(EV_REL, REL_X, -width * 2, true);
+    Dev(0).RelMotion(-width * 2, 0);
 
     ASSERT_EVENT(XEnterWindowEvent, lwin_enter, ldpy, EnterNotify);
     ASSERT_EQ(lwin_enter->window, lwin);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     ASSERT_EVENT(XButtonPressedEvent, lwin_press, ldpy, ButtonPress);
     ASSERT_EQ(lwin_enter->window, lwin);
     ASSERT_EVENT(XButtonPressedEvent, lwin_release, ldpy, ButtonRelease);
     ASSERT_EQ(lwin_enter->window, lwin);
 
-    dev->PlayOne(EV_REL, REL_X, width * 2, true);
+    Dev(0).RelMotion(width * 2, 0);
 
     ASSERT_EVENT(XLeaveWindowEvent, lwin_leave, ldpy, LeaveNotify);
     ASSERT_EQ(lwin_enter->window, lwin);
@@ -372,8 +377,8 @@ TEST_P(ZaphodTest, ScreenCrossingButtons)
     ASSERT_EVENT(XEnterWindowEvent, rwin_enter, rdpy, EnterNotify);
     ASSERT_EQ(rwin_enter->window, rwin);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     ASSERT_EVENT(XButtonPressedEvent, rwin_press, rdpy, ButtonPress);
     ASSERT_EQ(rwin_enter->window, rwin);
@@ -386,7 +391,6 @@ INSTANTIATE_TEST_CASE_P(, ZaphodTest, ::testing::Values(true, false));
 class XineramaTest : public ZaphodTest {
 public:
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE.desc");
         xinerama = true;
         left_of = GetParam();
         MultiheadTest::SetUp();
@@ -449,20 +453,20 @@ TEST_P(XineramaTest, ScreenCrossingButtons)
     XSelectInput(dpy, rwin, EnterWindowMask|LeaveWindowMask|ButtonPressMask|ButtonReleaseMask);
 
     WarpPointer(dpy, 201, height/2);
-    dev->PlayOne(EV_REL, REL_X, -10, true);
+    Dev(0).RelMotion(-10, 0);
 
     ASSERT_EVENT(XEnterWindowEvent, lwin_enter, dpy, EnterNotify);
     ASSERT_EQ(lwin_enter->window, lwin);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     ASSERT_EVENT(XButtonPressedEvent, lwin_press, dpy, ButtonPress);
     ASSERT_EQ(lwin_enter->window, lwin);
     ASSERT_EVENT(XButtonPressedEvent, lwin_release, dpy, ButtonRelease);
     ASSERT_EQ(lwin_enter->window, lwin);
 
-    dev->PlayOne(EV_REL, REL_X, width, true);
+    Dev(0).RelMotion(width, 0);
 
     ASSERT_EVENT(XLeaveWindowEvent, lwin_leave, dpy, LeaveNotify);
     ASSERT_EQ(lwin_enter->window, lwin);
@@ -470,8 +474,8 @@ TEST_P(XineramaTest, ScreenCrossingButtons)
     ASSERT_EVENT(XEnterWindowEvent, rwin_enter, dpy, EnterNotify);
     ASSERT_EQ(rwin_enter->window, rwin);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     ASSERT_EVENT(XButtonPressedEvent, rwin_press, dpy, ButtonPress);
     ASSERT_EQ(rwin_enter->window, rwin);
@@ -481,20 +485,28 @@ TEST_P(XineramaTest, ScreenCrossingButtons)
 
 INSTANTIATE_TEST_CASE_P(, XineramaTest, ::testing::Values(true, false));
 
-class ZaphodTouchDeviceChangeTest : public MultiheadTest,
-                                    public DeviceInterface {
+class ZaphodTouchDeviceChangeTest : public MultiheadTest {
 protected:
     virtual void SetUpConfigAndLog() {
         config.SetAutoAddDevices(true);
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-touch--",
+                               "Option \"CorePointer\" \"on\"\n"
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
+                               "Option \"CorePointer\" \"on\"\n"
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(1).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--keyboard-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(2).GetOptions());
+        config.AddServerLayoutOption("    Screen         0 \"Screen0\"");
+        config.AddServerLayoutOption(std::string() +
+            "    Screen         1 \"Screen1\" " + (left_of ? "LeftOf" : "RightOf") + " \"Screen0\"");
+        config.AddServerLayoutOption(std::string() +
+            "	Option         \"Xinerama\" \"" +  (xinerama ? "on" : "off") +"\"");
         config.AppendRawConfig(std::string() +
-            "Section \"ServerLayout\"\n"
-            "	Identifier     \"X.org Configured\"\n"
-            "	Screen         0 \"Screen0\"\n"
-            "	Screen         1 \"Screen1\" " + (left_of ? "LeftOf" : "RightOf") + " \"Screen0\"\n"
-            "	Option         \"Xinerama\" \"" + (xinerama ? "on" : "off") + "\"\n"
-            "	InputDevice    \"mouse\" \"CorePointer\"\n"
-            "EndSection\n"
-            "\n"
             "Section \"Device\"\n"
             "	Identifier  \"Card0\"\n"
             "	Driver      \"dummy\"\n"
@@ -513,30 +525,20 @@ protected:
             "Section \"Screen\"\n"
             "	Identifier \"Screen1\"\n"
             "	Device     \"Card1\"\n"
-            "EndSection"
-            "\n"
-            "Section \"InputDevice\"\n"
-            "	Identifier  \"mouse\"\n"
-            "	Driver      \"evdev\"\n"
-            "	Option      \"AccelerationProfile\" \"-1\"\n"
-            "	Option      \"CorePointer\" \"on\"\n"
-            "	Option \"Device\" \"" + mouse->GetDeviceNode() + "\"\n"
             "EndSection\n");
         config.WriteConfig();
     }
 
     virtual void SetUp() {
-        SetDevice("tablets/N-Trig-MultiTouch.desc");
-
-        mouse = std::unique_ptr<xorg::testing::evemu::Device>(
-                new xorg::testing::evemu::Device(
-                    RECORDINGS_DIR "/mice/PIXART-USB-OPTICAL-MOUSE.desc")
-                );
-
-        MultiheadTest::SetUp();
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
+        XITServerInputTest::SetUp();
     }
 
-    std::unique_ptr<xorg::testing::evemu::Device> mouse;
+    xorg::testing::inputtest::Device& TouchDev() { return Dev(0); }
+    xorg::testing::inputtest::Device& MouseDev() { return Dev(1); }
+    xorg::testing::inputtest::Device& KeyboardDev() { return Dev(2); }
 };
 
 TEST_F(ZaphodTouchDeviceChangeTest, NoCursorJumpsOnTouchToPointerSwitch)
@@ -551,14 +553,13 @@ TEST_F(ZaphodTouchDeviceChangeTest, NoCursorJumpsOnTouchToPointerSwitch)
 
     double x, y;
     do {
-        mouse->PlayOne(EV_REL, REL_X, 10, false);
-        mouse->PlayOne(EV_REL, REL_Y, 10, true);
+        MouseDev().RelMotion(10, 10);
         QueryPointerPosition(dpy, &x, &y);
     } while(x < DisplayWidth(dpy, DefaultScreen(dpy)) - 1 &&
             y < DisplayHeight(dpy, DefaultScreen(dpy))- 1);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchBegin(200, 200, 0);
+    TouchDev().TouchEnd(200, 200, 0);
 
     double touch_x, touch_y;
 
@@ -568,9 +569,9 @@ TEST_F(ZaphodTouchDeviceChangeTest, NoCursorJumpsOnTouchToPointerSwitch)
     ASSERT_NE(x, touch_x);
     ASSERT_NE(y, touch_y);
 
-    mouse->PlayOne(EV_REL, REL_X, 1, true);
+    MouseDev().RelMotion(1, 0);
     QueryPointerPosition(dpy, &x, &y);
 
-    ASSERT_EQ(touch_x + 1, x);
+    ASSERT_LE(std::abs(touch_x - x), 2);
     ASSERT_EQ(touch_y, y);
 }
diff --git a/tests/server/touch.cpp b/tests/server/touch.cpp
index 750562812a5061a03d02f69388271dd07d83ed9e..969e879ece92579334d2ab3549f02fe38d3069e6 100644
--- a/tests/server/touch.cpp
+++ b/tests/server/touch.cpp
@@ -30,7 +30,7 @@
 #include <tuple>
 
 #include "helpers.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 #include "xit-server-input-test.h"
 #include "xit-event.h"
 #include "xit-property.h"
@@ -42,10 +42,11 @@
 #include <X11/extensions/XInput2.h>
 
 class TouchTest : public XITServerInputTest,
-                  public DeviceInterface {
+                  public DeviceInputTestInterface {
 protected:
     virtual void SetUp() {
-        SetDevice("tablets/N-Trig-MultiTouch.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
         xi2_major_minimum = 2;
         xi2_minor_minimum = 2;
@@ -55,35 +56,64 @@ protected:
 
     virtual void SetUpConfigAndLog() {
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "N-Trig MultiTouch",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"Emulate3Buttons\" \"off\""
                                "Option \"CorePointer\" \"on\""
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
+                               "Option \"GrabDevice\" \"on\"\n"+
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-kbd--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
 
-    virtual void TouchBegin(int x, int y) {
-        dev->PlayOne(EV_KEY, BTN_TOUCH, 1);
-        TouchUpdate(x, y);
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
     }
+};
+
+class TouchTestWithMouse : public XITServerInputTest,
+                           public DeviceInputTestInterface {
+protected:
+
+    xorg::testing::inputtest::Device& TouchDev() { return Dev(0); }
+    xorg::testing::inputtest::Device& MouseDev() { return Dev(1); }
+    xorg::testing::inputtest::Device& KeyboardDev() { return Dev(2); }
+
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::TOUCH);
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
 
-    virtual void TouchUpdate(int x, int y) {
-        dev->PlayOne(EV_ABS, ABS_X, x);
-        dev->PlayOne(EV_ABS, ABS_Y, y);
-        dev->PlayOne(EV_ABS, ABS_MT_POSITION_X, x);
-        dev->PlayOne(EV_ABS, ABS_MT_POSITION_Y, y);
-        /* same values as the recordings file */
-        dev->PlayOne(EV_ABS, ABS_MT_ORIENTATION, 0);
-        dev->PlayOne(EV_ABS, ABS_MT_TOUCH_MAJOR, 468);
-        dev->PlayOne(EV_ABS, ABS_MT_TOUCH_MINOR, 306);
-        dev->PlayOne(EV_SYN, SYN_MT_REPORT, 0);
-        dev->PlayOne(EV_SYN, SYN_REPORT, 0);
+        xi2_major_minimum = 2;
+        xi2_minor_minimum = 2;
+
+        XITServerInputTest::SetUp();
     }
 
-    virtual void TouchEnd() {
-        dev->PlayOne(EV_KEY, BTN_TOUCH, 0);
-        dev->PlayOne(EV_SYN, SYN_REPORT, 0);
+    void SetUpConfigAndLog() override {
+        config.AddDefaultScreenWithDriver();
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
+                               "Option \"Emulate3Buttons\" \"off\""
+                               "Option \"CorePointer\" \"on\""
+                               "Option \"GrabDevice\" \"on\"\n"+
+                               Dev(0).GetOptions());
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-mouse--",
+                               "Option \"CorePointer\" \"on\""
+                               "Option \"GrabDevice\" \"on\"\n"+
+                               Dev(1).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device-kbd--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(2).GetOptions());
+        config.WriteConfig();
+    }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
     }
 };
 
@@ -104,8 +134,8 @@ TEST_F(TouchTest, TouchEventFlags)
     XISelectEvents(dpy, DefaultRootWindow(dpy), &mask, 1);
     delete[] mask.mask;
 
-    TouchBegin(100, 100);
-    TouchEnd();
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchEnd(100, 100, 0);
 
     ASSERT_EVENT(XIDeviceEvent, tbegin, dpy, GenericEvent, xi2_opcode, XI_TouchBegin);
     ASSERT_EVENT(XIDeviceEvent, tend, dpy, GenericEvent, xi2_opcode, XI_TouchEnd);
@@ -137,7 +167,22 @@ protected:
     }
 };
 
-TEST_P(TouchTestXI2Version, XITouchscreenPointerEmulation)
+class TouchTestXI2VersionWithMouse : public TouchTestWithMouse,
+                                     public ::testing::WithParamInterface<int> {
+protected:
+    virtual void SetUpConfigAndLog()
+    {
+        config.SetAutoAddDevices(true);
+        TouchTestWithMouse::SetUpConfigAndLog();
+    }
+
+    virtual void RequireXI2(int major, int minor, int *maj_ret, int *min_ret)
+    {
+        XITServerInputTest::RequireXI2(2, GetParam());
+    }
+};
+
+TEST_P(TouchTestXI2VersionWithMouse, XITouchscreenPointerEmulation)
 {
     XORG_TESTCASE("Register for button and motion events.\n"
                   "Create a touch and a pointer device.\n"
@@ -147,7 +192,8 @@ TEST_P(TouchTestXI2Version, XITouchscreenPointerEmulation)
                   "Release the touch point.\n"
                   "Moving the mouse now must have a zero button mask.\n");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
+    WaitForDevice("--device-mouse--");
 
     XIEventMask mask;
     mask.deviceid = XIAllMasterDevices;
@@ -163,25 +209,12 @@ TEST_P(TouchTestXI2Version, XITouchscreenPointerEmulation)
 
     XFlush(Display());
 
-    std::unique_ptr<xorg::testing::evemu::Device> mouse_device;
-    try {
-      mouse_device = std::unique_ptr<xorg::testing::evemu::Device>(
-          new xorg::testing::evemu::Device(
-              RECORDINGS_DIR "mice/PIXART-USB-OPTICAL-MOUSE.desc")
-          );
-    } catch (std::runtime_error &error) {
-      std::cerr << "Failed to create evemu device, skipping test.\n";
-      return;
-    }
-
-    WaitForDevice("PIXART USB OPTICAL MOUSE");
-
     XEvent event;
     XGenericEventCookie *xcookie;
     XIDeviceEvent *device_event;
 
     /* Move the mouse, check that the button is not pressed. */
-    mouse_device->PlayOne(EV_REL, ABS_X, -1, 1);
+    MouseDev().RelMotion(-1, 0);
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
                                                            xi2_opcode,
@@ -197,7 +230,7 @@ TEST_P(TouchTestXI2Version, XITouchscreenPointerEmulation)
 
 
     /* Touch the screen, wait for press event */
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    TouchDev().TouchBegin(100, 100, 0);
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
                                                            xi2_opcode,
@@ -207,7 +240,7 @@ TEST_P(TouchTestXI2Version, XITouchscreenPointerEmulation)
 
 
     /* Move the mouse again, button 1 should now be pressed. */
-    mouse_device->PlayOne(EV_REL, ABS_X, -1, 1);
+    MouseDev().RelMotion(-1, 0);
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
                                                            xi2_opcode,
@@ -223,7 +256,7 @@ TEST_P(TouchTestXI2Version, XITouchscreenPointerEmulation)
 
 
     /* Release the screen, wait for release event */
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    TouchDev().TouchEnd(100, 100, 0);
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
                                                            xi2_opcode,
@@ -233,7 +266,7 @@ TEST_P(TouchTestXI2Version, XITouchscreenPointerEmulation)
 
 
     /* Move the mouse again, button 1 should now be released. */
-    mouse_device->PlayOne(EV_REL, ABS_X, -1, 1);
+    MouseDev().RelMotion(-1, 0);
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
                                                            xi2_opcode,
@@ -257,14 +290,14 @@ TEST_P(TouchTestXI2Version, EmulatedButtonMaskOnTouchBeginEndCore)
                   "The button mask in the button press event must be 0.\n"
                   "The button mask in the button release event must be set for button 1.");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     XSelectInput(Display(), DefaultRootWindow(Display()),
                  PointerMotionMask|ButtonPressMask|ButtonReleaseMask);
     XSync(Display(), False);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchEnd(100, 100, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            MotionNotify,
@@ -300,15 +333,15 @@ TEST_P(TouchTestXI2Version, NoEmulatedButton1MotionWithoutButtonPress)
                   "No motion event expected\n"
                   "https://bugs.freedesktop.org/show_bug.cgi?id=60394");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     ::Display *dpy = Display();
     XSelectInput(dpy, DefaultRootWindow(dpy), Button1MotionMask);
     XSync(dpy, False);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_update.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchUpdate(200, 200, 0);
+    Dev(0).TouchEnd(200, 200, 0);
 
     ASSERT_TRUE(NoEventPending(dpy));
 }
@@ -319,15 +352,15 @@ TEST_P(TouchTestXI2Version, EmulatedButton1MotionMaskOnTouch)
                   "Create a pointer-emulating touch event.\n"
                   "Expect a motion event with the button mask 1.\n");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     ::Display *dpy = Display();
     XSelectInput(dpy, DefaultRootWindow(dpy), ButtonPressMask | Button1MotionMask);
     XSync(dpy, False);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_update.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchUpdate(200, 200, 0);
+    Dev(0).TouchEnd(200, 200, 0);
 
     ASSERT_EVENT(XEvent, press, dpy, ButtonPress);
     ASSERT_EVENT(XEvent, motion, dpy, MotionNotify);
@@ -343,7 +376,7 @@ TEST_P(TouchTestXI2Version, EmulatedButtonMaskOnTouchBeginEndXI2)
                   "The button mask in the button press event must be 0.\n"
                   "The button mask in the button release event must be set for button 1.");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     XIEventMask mask;
     mask.deviceid = VIRTUAL_CORE_POINTER_ID;
@@ -358,8 +391,8 @@ TEST_P(TouchTestXI2Version, EmulatedButtonMaskOnTouchBeginEndXI2)
     XSync(Display(), False);
     delete[] mask.mask;
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchEnd(100, 100, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
@@ -424,7 +457,7 @@ TEST_P(TouchTestXI2Version, XIQueryPointerTouchscreen)
                   " - button 1 state down for XI 2.0 and 2.1 clients\n"
                   " - button 1 state up for XI 2.2+ clients");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     XIEventMask mask;
     mask.deviceid = XIAllMasterDevices;
@@ -440,7 +473,7 @@ TEST_P(TouchTestXI2Version, XIQueryPointerTouchscreen)
 
     XFlush(Display());
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+    Dev(0).TouchBegin(100, 100, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
@@ -482,70 +515,6 @@ TEST_P(TouchTestXI2Version, XIQueryPointerTouchscreen)
 
 class TouchDeviceTest : public TouchTest {};
 
-TEST_F(TouchDeviceTest, DisabledDevice)
-{
-    XORG_TESTCASE("Disable device\n"
-                  "Send events\n"
-                  "Enable device\n"
-                  "Ensure no events are waiting");
-
-    ::Display *dpy = Display();
-
-    int deviceid;
-    ASSERT_EQ(FindInputDeviceByName(dpy, "N-Trig MultiTouch", &deviceid), 1);
-
-    SelectXI2Events(dpy, XIAllMasterDevices, DefaultRootWindow(dpy),
-                    XI_TouchBegin, XI_TouchUpdate, XI_TouchEnd, -1);
-
-    ASSERT_PROPERTY(int, prop_enabled, dpy, deviceid, "Device Enabled");
-    prop_enabled.data[0] = 0;
-    prop_enabled.Update();
-
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
-
-    XSync(dpy, False);
-    prop_enabled.data[0] = 1;
-    prop_enabled.Update();
-
-    ASSERT_TRUE(NoEventPending(dpy));
-}
-
-TEST_F(TouchDeviceTest, TouchStartsInDisabledDevice)
-{
-    XORG_TESTCASE("Disable device\n"
-                  "Send touch start\n"
-                  "Enable device\n"
-                  "Continue with touch events\n"
-                  "Ensure no events are waiting");
-
-    ::Display *dpy = Display();
-
-    int deviceid;
-    ASSERT_EQ(FindInputDeviceByName(dpy, "N-Trig MultiTouch", &deviceid), 1);
-
-    SelectXI2Events(dpy, XIAllMasterDevices, DefaultRootWindow(dpy),
-                    XI_TouchBegin, XI_TouchUpdate, XI_TouchEnd, -1);
-
-    ASSERT_PROPERTY(int, prop_enabled, dpy, deviceid, "Device Enabled");
-    prop_enabled.data[0] = 0;
-    prop_enabled.Update();
-
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-
-    XSync(dpy, False);
-    prop_enabled.data[0] = 1;
-    prop_enabled.Update();
-
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
-
-    ASSERT_TRUE(NoEventPending(dpy));
-
-    const std::string error = "unable to find touch point";
-    ASSERT_FALSE(SearchFileForString(server.GetLogFilePath(), error));
-}
-
-
 TEST_F(TouchDeviceTest, DisableDeviceEndTouches)
 {
     XORG_TESTCASE("Register for touch events.\n"
@@ -569,9 +538,10 @@ TEST_F(TouchDeviceTest, DisableDeviceEndTouches)
 
     XFlush(Display());
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
+
+    Dev(0).TouchBegin(100, 100, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
@@ -722,7 +692,7 @@ TEST_F(TouchTest, TouchEventsButtonState)
                   "Create a pointer-emulating touch event.\n"
                   "The button mask in the touch begin, update, and end event must be 0.");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     XIEventMask mask;
     mask.deviceid = VIRTUAL_CORE_POINTER_ID;
@@ -737,8 +707,8 @@ TEST_F(TouchTest, TouchEventsButtonState)
     XSync(Display(), False);
     delete[] mask.mask;
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchEnd(100, 100, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
@@ -878,8 +848,8 @@ TEST_P(TouchEventHistoryTest, EventHistoryReplay) {
 
     XSync(Display(), False);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchEnd(100, 100, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
@@ -972,28 +942,7 @@ INSTANTIATE_TEST_CASE_P(, TouchEventHistoryTest,
                         ::testing::ValuesIn(generate_event_history_test_cases(WINDOW_HIERARCHY_DEPTH)));
 
 
-class TouchDeviceChangeTest : public TouchTest {
-protected:
-    virtual void SetUp() {
-        mouse = std::unique_ptr<xorg::testing::evemu::Device>(
-                new xorg::testing::evemu::Device(
-                    RECORDINGS_DIR "/mice/PIXART-USB-OPTICAL-MOUSE.desc")
-                );
-
-        TouchTest::SetUp();
-    }
-
-    virtual void SetUpConfigAndLog() {
-        config.AddInputSection("evdev", "mouse",
-                               "Option \"CorePointer\" \"on\""
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"AccelerationProfile\" \"-1\""
-                               "Option \"Device\" \"" + mouse->GetDeviceNode() + "\"");
-        TouchTest::SetUpConfigAndLog();
-    }
-
-    std::unique_ptr<xorg::testing::evemu::Device> mouse;
-};
+class TouchDeviceChangeTest : public TouchTestWithMouse {};
 
 TEST_F(TouchDeviceChangeTest, NoCursorJumpsOnTouchToPointerSwitch)
 {
@@ -1007,14 +956,15 @@ TEST_F(TouchDeviceChangeTest, NoCursorJumpsOnTouchToPointerSwitch)
 
     double x, y;
     do {
-        mouse->PlayOne(EV_REL, REL_X, 10, false);
-        mouse->PlayOne(EV_REL, REL_Y, 10, true);
+        MouseDev().RelMotion(10, 0);
+        MouseDev().RelMotion(10, 0);
         QueryPointerPosition(dpy, &x, &y);
     } while(x < DisplayWidth(dpy, DefaultScreen(dpy)) - 1 &&
             y < DisplayHeight(dpy, DefaultScreen(dpy))- 1);
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+
+    Dev(0).TouchBegin(200, 200, 0);
+    Dev(0).TouchEnd(200, 200, 0);
 
     double touch_x, touch_y;
 
@@ -1024,10 +974,10 @@ TEST_F(TouchDeviceChangeTest, NoCursorJumpsOnTouchToPointerSwitch)
     ASSERT_NE(x, touch_x);
     ASSERT_NE(y, touch_y);
 
-    mouse->PlayOne(EV_REL, REL_X, 1, true);
+    MouseDev().RelMotion(1, 0);
     QueryPointerPosition(dpy, &x, &y);
 
-    ASSERT_EQ(touch_x + 1, x);
+    ASSERT_LE(std::abs(touch_x - x), 2);
     ASSERT_EQ(touch_y, y);
 }
 
@@ -1040,8 +990,8 @@ TEST_F(TouchDeviceChangeTest, DeviceChangedEventTouchToPointerSwitch)
 
     ::Display *dpy = Display();
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchEnd(100, 100, 0);
 
     XSync(dpy, False);
 
@@ -1055,7 +1005,7 @@ TEST_F(TouchDeviceChangeTest, DeviceChangedEventTouchToPointerSwitch)
               XISelectEvents(Display(), DefaultRootWindow(Display()), &mask, 1));
     XSync(Display(), False);
     delete[] mask.mask;
-    mouse->PlayOne(EV_REL, REL_X, 1, true);
+    MouseDev().RelMotion(1, 0);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(Display(),
                                                            GenericEvent,
@@ -1069,7 +1019,7 @@ TEST_F(TouchDeviceChangeTest, DeviceChangedEventTouchToPointerSwitch)
     ASSERT_TRUE(XGetEventData(Display(), &ev.xcookie));
 
     int deviceid;
-    ASSERT_EQ(FindInputDeviceByName(dpy, "mouse", &deviceid), 1);
+    ASSERT_EQ(FindInputDeviceByName(dpy, "--device-mouse--", &deviceid), 1);
 
     XIDeviceChangedEvent *cev = reinterpret_cast<XIDeviceChangedEvent*>(ev.xcookie.data);
     ASSERT_EQ(cev->deviceid, VIRTUAL_CORE_POINTER_ID);
@@ -1084,11 +1034,11 @@ TEST_F(TouchDeviceChangeTest, DeviceChangedEventPointerToTouchSwitch)
                   "Touch and release from the touch device\n"
                   "Expect a DeviceChangedEvent for the touch device on the VCP\n");
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     ::Display *dpy = Display();
 
-    mouse->PlayOne(EV_REL, REL_X, 1, true);
+    MouseDev().RelMotion(10, 0);
 
     XIEventMask mask;
     mask.deviceid = VIRTUAL_CORE_POINTER_ID;
@@ -1101,8 +1051,8 @@ TEST_F(TouchDeviceChangeTest, DeviceChangedEventPointerToTouchSwitch)
     XSync(dpy, False);
     delete[] mask.mask;
 
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_begin.events");
-    dev->Play(RECORDINGS_DIR "tablets/N-Trig-MultiTouch.touch_1_end.events");
+    Dev(0).TouchBegin(100, 100, 0);
+    Dev(0).TouchEnd(100, 100, 0);
 
     XSync(dpy, False);
 
@@ -1118,7 +1068,7 @@ TEST_F(TouchDeviceChangeTest, DeviceChangedEventPointerToTouchSwitch)
     ASSERT_TRUE(XGetEventData(dpy, &ev.xcookie));
 
     int deviceid;
-    ASSERT_EQ(FindInputDeviceByName(dpy, "N-Trig MultiTouch", &deviceid), 1);
+    ASSERT_EQ(FindInputDeviceByName(dpy, "--device--", &deviceid), 1);
 
     XIDeviceChangedEvent *cev = reinterpret_cast<XIDeviceChangedEvent*>(ev.xcookie.data);
     ASSERT_EQ(cev->deviceid, VIRTUAL_CORE_POINTER_ID);
@@ -1139,10 +1089,10 @@ TEST_F(TouchTest, JumpingCursorOnTransformationMatrix)
 
     ::Display *dpy = Display();
 
-    WaitForDevice("N-Trig MultiTouch");
+    WaitForDevice("--device--");
 
     int deviceid;
-    ASSERT_EQ(FindInputDeviceByName(dpy, "N-Trig MultiTouch", &deviceid), 1);
+    ASSERT_EQ(FindInputDeviceByName(dpy, "--device--", &deviceid), 1);
 
     Atom matrix_prop = XInternAtom(dpy, "Coordinate Transformation Matrix", True);
     ASSERT_NE(matrix_prop, (Atom)None);
@@ -1162,19 +1112,19 @@ TEST_F(TouchTest, JumpingCursorOnTransformationMatrix)
                      reinterpret_cast<unsigned char*>(matrix), 9);
     XSync(dpy, False);
 
-    TouchBegin(2745, 1639);
+    Dev(0).TouchBegin(2745, 1639, 0);
 
     double x1, y1;
     double x2, y2;
 
     QueryPointerPosition(dpy, &x1, &y1);
-    TouchUpdate(5000,1639);
+    Dev(0).TouchUpdate(5000, 1639, 0);
     QueryPointerPosition(dpy, &x2, &y2);
 
     ASSERT_NE(x1, x2);
     ASSERT_EQ(y1, y2);
 
-    TouchEnd();
+    Dev(0).TouchEnd(5000, 1639, 0);
 
     /* Test with X coordinate scaled */
 
@@ -1187,17 +1137,18 @@ TEST_F(TouchTest, JumpingCursorOnTransformationMatrix)
                      reinterpret_cast<unsigned char*>(matrix), 9);
     XSync(dpy, False);
 
-    TouchBegin(2745, 1639);
+    Dev(0).TouchBegin(2745, 1639, 0);
     QueryPointerPosition(dpy, &x1, &y1);
-    TouchUpdate(2745, 2000);
+    Dev(0).TouchUpdate(2745, 2000, 0);
     QueryPointerPosition(dpy, &x2, &y2);
 
     ASSERT_EQ(x1, x2);
     ASSERT_NE(y1, y2);
 
-    TouchEnd();
+    Dev(0).TouchEnd(2745, 2000, 0);
 }
 
 
 INSTANTIATE_TEST_CASE_P(, TouchTestXI2Version, ::testing::Range(0, XI_2_Minor + 1));
+INSTANTIATE_TEST_CASE_P(, TouchTestXI2VersionWithMouse, ::testing::Range(0, XI_2_Minor + 1));
 
diff --git a/tests/server/xigrabbutton.cpp b/tests/server/xigrabbutton.cpp
index c6648740dee23976f03856d968ed60cdac89adfc..f9c882812800bfe4c776051f7bbff5ace4c979d4 100644
--- a/tests/server/xigrabbutton.cpp
+++ b/tests/server/xigrabbutton.cpp
@@ -32,38 +32,45 @@
 #include <X11/extensions/XInput2.h>
 
 #include "xit-server-input-test.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 #include "helpers.h"
 
 
 /**
  */
 class XIGrabButtonTest : public XITServerInputTest,
-                         public DeviceInterface {
+                         public DeviceInputTestInterface {
 public:
     /**
      * Initializes a wacom pad device.
      */
-    virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE.desc");
+    void SetUp() override {
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XITServerInputTest::SetUp();
     }
 
     /**
      */
-    virtual void SetUpConfigAndLog() {
+    void SetUpConfigAndLog() override {
 
         config.SetAutoAddDevices(false);
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
-                               "    Option \"Device\" \"" + dev->GetDeviceNode() + "\""
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "    Option \"CorePointer\" \"on\"\n"
-                               "    Option \"GrabDevice\" \"on\"\n");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "    Option \"CoreKeyboard\" \"on\"\n");
+                               "    Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--kbd-device--",
+                               "    Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 static int
@@ -161,11 +168,11 @@ TEST_F(XIGrabButtonTest, GrabWindowTest)
     // First, check without the grab, the top win should get the event
     XSync(dpy2, False);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
+    Dev(0).ButtonDown(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy2, ButtonPress, -1, -1));
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonUp(1);
 
     XEvent ev;
     XNextEvent(dpy2, &ev);
@@ -188,8 +195,8 @@ TEST_F(XIGrabButtonTest, GrabWindowTest)
     grab_buttons (dpy1, DefaultRootWindow(dpy1), deviceid);
     XSync(dpy1, False);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, true);
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, true);
+    Dev(0).ButtonDown(1);
+    Dev(0).ButtonUp(1);
 
     ASSERT_TRUE(xorg::testing::XServer::WaitForEventOfType(dpy1,
                                                            GenericEvent,
diff --git a/tests/server/xtest.cpp b/tests/server/xtest.cpp
index 39ed876de58691cface5c8a6c6452928cfd9553c..429f3a48859641135139bff182d8d9d3ddcb3a46 100644
--- a/tests/server/xtest.cpp
+++ b/tests/server/xtest.cpp
@@ -36,7 +36,7 @@
 
 #include "xorg-conf.h"
 #include "xit-server-input-test.h"
-#include "device-interface.h"
+#include "device-inputtest-interface.h"
 #include "xit-server.h"
 #include "xit-event.h"
 #include "helpers.h"
@@ -147,28 +147,35 @@ TEST(XTest, DisabledDevicesCtl)
 }
 
 class XTestPhysicalDeviceTest : public XITServerInputTest,
-                                public DeviceInterface {
+                                public DeviceInputTestInterface {
 public:
     /**
      * Initializes a standard mouse device.
      */
     virtual void SetUp() {
-        SetDevice("mice/PIXART-USB-OPTICAL-MOUSE-HWHEEL.desc");
+        AddDevice(xorg::testing::inputtest::DeviceType::POINTER);
+        AddDevice(xorg::testing::inputtest::DeviceType::KEYBOARD);
         XITServerInputTest::SetUp();
     }
 
     virtual void SetUpConfigAndLog() {
 
         config.AddDefaultScreenWithDriver();
-        config.AddInputSection("evdev", "--device--",
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--device--",
                                "Option \"CorePointer\" \"on\"\n"
-                               "Option \"GrabDevice\" \"on\"\n"
-                               "Option \"Device\" \"" + dev->GetDeviceNode() + "\"");
-        /* add default keyboard device to avoid server adding our device again */
-        config.AddInputSection("kbd", "kbd-device",
-                               "Option \"CoreKeyboard\" \"on\"\n");
+                               "Option \"GrabDevice\" \"on\"\n" +
+                               Dev(0).GetOptions());
+        /* add default keyboard device */
+        config.AddInputSection(XORG_INPUTTEST_DRIVER, "--kbd-device--",
+                               "Option \"CoreKeyboard\" \"on\"\n" +
+                               Dev(1).GetOptions());
         config.WriteConfig();
     }
+
+    void StartServer() override {
+        XITServerInputTest::StartServer();
+        WaitForDevices();
+    }
 };
 
 TEST_F(XTestPhysicalDeviceTest, ReleaseXTestOnPhysicalRelease)
@@ -184,14 +191,14 @@ TEST_F(XTestPhysicalDeviceTest, ReleaseXTestOnPhysicalRelease)
 
     XSelectInput(dpy, DefaultRootWindow(dpy), ButtonPressMask|ButtonReleaseMask);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 1, True);
+    Dev(0).ButtonDown(1);
 
     ASSERT_EVENT(XButtonEvent, press, dpy, ButtonPress);
     ASSERT_EQ(press->button, 1U);
 
     XTestFakeButtonEvent(dpy, 1, 1, 0);
 
-    dev->PlayOne(EV_KEY, BTN_LEFT, 0, True);
+    Dev(0).ButtonUp(1);
 
     ASSERT_EVENT(XButtonEvent, release, dpy, ButtonRelease);
     ASSERT_EQ(release->button, 1U);