QtMir

src/platforms/mirserver/eventbuilder.cpp (+69/-15)
src/platforms/mirserver/eventbuilder.h (+11/-6)
src/platforms/mirserver/qteventfeeder.cpp (+10/-9)
tests/mirserver/EventBuilder/eventbuilder_test.cpp (+85/-4)

To merge this branch:

bzr merge lp:~andreas-pokorny/qtmir/store-and-recover-cookie-and-input-device-id

Related bugs:

Bug #1536279: Mir does not reset key states when paused or resumed (modifiers get stuck after VT switching)	High	Fix Released
Bug #1668692: Deliver Mir cookie to clients	Undecided	Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Daniel d'Andrada (community)		2017-02-28	Approve on 2017-03-03
Unity8 CI Bot	continuous-integration		Approve on 2017-03-03
Review via email: mp+318528@code.launchpad.net

Commit Message

Attach MirInputDeviceId and the MirCookie to input events

Similar to the tracking of relative motion the cookie and input device ids of mir events are stored in the EventBuilder for later recovery

Description of the Change

This expands the storage and recovery of input event properties that cannot be reflected with a regular QtEvent onto the optional cookie and the input device id. The Input device id is crucial in tracking the key states in mirclient. E.g. the MirInputDeviceState event which is sent on focus change containing the pressed keys and toggled modifier states per devices, refers to the keyboards by using the input device id.

Since this is in the same area of the code and dnd is needed soon the cookie attribute of the MirInputEvent is also stored.

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-02-28:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/531/rebuild

review: Approve (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2017-03-02:

Please update copyright years in the files you modified.

Daniel d'Andrada (dandrader) wrote on 2017-03-02:

With this branch I'm getting tons of "qtmir.mir.input: EventBuilder::makeMirEvent didn't find EventInfo with timestamp xxx" messages

Daniel d'Andrada (dandrader) on 2017-03-02:

review: Needs Fixing

Daniel d'Andrada (dandrader) wrote on 2017-03-02:

Worth passing the timestamp to QtEventFeeder::dispatchPointer() to avoid calculating it twice

lp:~andreas-pokorny/qtmir/store-and-recover-cookie-and-input-device-id updated on 2017-03-03

610. By Andreas Pokorny on 2017-03-03

Move storing of EventInfo into dispatch* methods

QtEventFeeder::dispatch is only used by tests.

611. By Andreas Pokorny on 2017-03-03

update years

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-03:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/553/rebuild

review: Needs Fixing (continuous-integration)

Unity8 CI Bot (unity8-ci-bot) wrote on 2017-03-03:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtmir-ci/554/rebuild

review: Approve (continuous-integration)

Daniel d'Andrada (dandrader) wrote on 2017-03-03:

Looking good.

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes

* Did CI run pass? If not, please explain why.
Yes

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Andreas Pokorny

Daniel d'Andrada

Mir development team

 === modified file 'src/platforms/mirserver/eventbuilder.cpp'
 --- src/platforms/mirserver/eventbuilder.cpp	2016-09-08 22:46:57 +0000
 +++ src/platforms/mirserver/eventbuilder.cpp	2017-03-03 10:39:42 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2016 Canonical, Ltd.
++ * Copyright (C) 2016-2017 Canonical, Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License version 3, as published by
@@ -22,6 +22,7 @@
  #include <timestamp.h>
  #include <mir_toolkit/event.h>
++#include <mir_toolkit/mir_cookie.h>
  #include <QDebug>
@@ -104,10 +105,10 @@
      m_instance = nullptr;
+ }
--void EventBuilder::store(const MirPointerEvent *mirPointerEvent, ulong qtTimestamp)
++void EventBuilder::store(const MirInputEvent *mirInputEvent, ulong qtTimestamp)
+ {
      EventInfo &eventInfo = m_eventInfoVector[m_nextIndex];
--    eventInfo.store(mirPointerEvent, qtTimestamp);
++    eventInfo.store(mirInputEvent, qtTimestamp);
      m_nextIndex = (m_nextIndex + 1) % m_eventInfoVector.size();
@@ -136,21 +137,24 @@
      float relativeX = 0.;
      float relativeY = 0.;
++    MirInputDeviceId deviceId = 0;
++    std::vector<uint8_t> cookie{};
--    EventInfo *eventInfo = nullptr;
      // Timestamp will be zero in case of synthetic events. Particularly synthetic QHoverEvents caused
      // by item movement under a stationary mouse pointer.
      if (qtEvent->timestamp() != 0) {
--        eventInfo = findInfo(qtEvent->timestamp());
++        auto eventInfo = findInfo(qtEvent->timestamp());
          if (eventInfo) {
              relativeX = eventInfo->relativeX;
              relativeY = eventInfo->relativeY;
++            deviceId = eventInfo->deviceId;
++            cookie = eventInfo->cookie;
          } else {
              qCWarning(QTMIR_MIR_INPUT) << "EventBuilder::makeMirEvent didn't find EventInfo with timestamp" << qtEvent->timestamp();
+         }
+     }
--    return mir::events::make_event(0 /*DeviceID */, timestamp, std::vector<uint8_t>{} /* cookie */, modifiers, action,
++    return mir::events::make_event(deviceId, timestamp, cookie, modifiers, action,
                                     buttons, x, y, 0 /*hscroll*/, 0 /*vscroll*/, relativeX, relativeY);
+ }
@@ -160,11 +164,24 @@
      auto modifiers = getMirModifiersFromQt(qtEvent->modifiers());
      auto buttons = getMirButtonsFromQt(qtEvent->buttons());
++    MirInputDeviceId deviceId = 0;
++    std::vector<uint8_t> cookie{};
++
      QPointF mirScroll(qtEvent->angleDelta());
      // QWheelEvent::DefaultDeltasPerStep = 120 but not defined on vivid
      mirScroll /= 120.0f;
--    return mir::events::make_event(0 /*DeviceID */, timestamp, std::vector<uint8_t>{} /* cookie */, modifiers, mir_pointer_action_motion,
++    if (qtEvent->timestamp() != 0) {
++        auto eventInfo = findInfo(qtEvent->timestamp());
++        if (eventInfo) {
++            deviceId = eventInfo->deviceId;
++            cookie = eventInfo->cookie;
++        } else {
++            qCWarning(QTMIR_MIR_INPUT) << "EventBuilder::makeMirEvent didn't find EventInfo with timestamp" << qtEvent->timestamp();
++        }
++    }
++
++    return mir::events::make_event(deviceId, timestamp, cookie, modifiers, mir_pointer_action_motion,
                                     buttons, qtEvent->x(), qtEvent->y(),
                                     mirScroll.x(), mirScroll.y(),
 , 0);
@@ -186,9 +203,21 @@
+     }
      if (qtEvent->isAutoRepeat())
          action = mir_keyboard_action_repeat;
--
--    return mir::events::make_event(0 /* DeviceID */, uncompressTimestamp<qtmir::Timestamp>(qtmir::Timestamp(qtEvent->timestamp())),
--                           std::vector<uint8_t>{} /* cookie */, action, qtEvent->nativeVirtualKey(),
++    MirInputDeviceId deviceId = 0;
++    std::vector<uint8_t> cookie{};
++
++    if (qtEvent->timestamp() != 0) {
++        auto eventInfo = findInfo(qtEvent->timestamp());
++        if (eventInfo) {
++            deviceId = eventInfo->deviceId;
++            cookie = eventInfo->cookie;
++        } else {
++            qCWarning(QTMIR_MIR_INPUT) << "EventBuilder::makeMirEvent didn't find EventInfo with timestamp" << qtEvent->timestamp();
++        }
++    }
++
++    return mir::events::make_event(deviceId, uncompressTimestamp<qtmir::Timestamp>(qtmir::Timestamp(qtEvent->timestamp())),
++                           cookie, action, qtEvent->nativeVirtualKey(),
                             qtEvent->nativeScanCode(),
                             qtEvent->nativeModifiers());
+ }
@@ -198,9 +227,22 @@
                              Qt::TouchPointStates /* qtTouchPointStates */,
                              ulong qtTimestamp)
+ {
++    MirInputDeviceId deviceId = 0;
++    std::vector<uint8_t> cookie{};
++
++    if (qtTimestamp != 0) {
++        auto eventInfo = findInfo(qtTimestamp);
++        if (eventInfo) {
++            deviceId = eventInfo->deviceId;
++            cookie = eventInfo->cookie;
++        } else {
++            qCWarning(QTMIR_MIR_INPUT) << "EventBuilder::makeMirEvent didn't find EventInfo with timestamp" << qtTimestamp;
++        }
++    }
++
      auto modifiers = getMirModifiersFromQt(qmods);
--    auto ev = mir::events::make_event(0, uncompressTimestamp<qtmir::Timestamp>(qtmir::Timestamp(qtTimestamp)),
--                                      std::vector<uint8_t>{} /* cookie */, modifiers);
++    auto ev = mir::events::make_event(deviceId, uncompressTimestamp<qtmir::Timestamp>(qtmir::Timestamp(qtTimestamp)),
++                                      cookie, modifiers);
      for (int i = 0; i < qtTouchPoints.count(); ++i) {
          auto touchPoint = qtTouchPoints.at(i);
@@ -241,9 +283,21 @@
      return nullptr;
+ }
--void EventBuilder::EventInfo::store(const MirPointerEvent *pev, ulong qtTimestamp)
++void EventBuilder::EventInfo::store(const MirInputEvent *iev, ulong qtTimestamp)
+ {
      this->qtTimestamp = qtTimestamp;
--    relativeX = mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_x);
--    relativeY = mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_y);
++    deviceId = mir_input_event_get_device_id(iev);
++    if (mir_input_event_has_cookie(iev))
++    {
++        auto cookie_ptr = mir_input_event_get_cookie(iev);
++        cookie.resize(mir_cookie_buffer_size(cookie_ptr));
++        mir_cookie_to_buffer(cookie_ptr, cookie.data(), cookie.size());
++        mir_cookie_release(cookie_ptr);
++    }
++    if (mir_input_event_type_pointer == mir_input_event_get_type(iev))
++    {
++        auto pev = mir_input_event_get_pointer_event(iev);
++        relativeX = mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_x);
++        relativeY = mir_pointer_event_axis_value(pev, mir_pointer_axis_relative_y);
++    }
+ }
 === modified file 'src/platforms/mirserver/eventbuilder.h'
 --- src/platforms/mirserver/eventbuilder.h	2016-09-08 22:46:57 +0000
 +++ src/platforms/mirserver/eventbuilder.h	2017-03-03 10:39:42 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2016 Canonical, Ltd.
++ * Copyright (C) 2016-2017 Canonical, Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License version 3, as published by
@@ -46,7 +46,7 @@
      /* Stores information that cannot be carried by QInputEvents so that it can be fully
         reconstructed later given the same qtTimestamp */
--    void store(const MirPointerEvent *mirPointerEvent, ulong qtTimestamp);
++    void store(const MirInputEvent *mirInputEvent, ulong qtTimestamp);
      /*
          Builds a MirEvent version of the given QInputEvent using also extra data from the
@@ -58,7 +58,10 @@
      mir::EventUPtr reconstructMirEvent(QHoverEvent *qtEvent);
      /*
--        Makes a MirEvent version of the given QInputEvent
++        Makes a MirEvent version of the given QInputEvent using also extra data from the
++        MirInputEvent that caused it.
++
++        See also: store()
       */
      mir::EventUPtr makeMirEvent(QWheelEvent *qtEvent);
      mir::EventUPtr makeMirEvent(QKeyEvent *qtEvent);
@@ -69,8 +72,10 @@
  private:
      class EventInfo {
      public:
--        void store(const MirPointerEvent *mirPointerEvent, ulong qtTimestamp);
++        void store(const MirInputEvent *mirInputEvent, ulong qtTimestamp);
          ulong qtTimestamp;
++        MirInputDeviceId deviceId;
++        std::vector<uint8_t> cookie;
          float relativeX{0};
          float relativeY{0};
      };
@@ -85,8 +90,8 @@
        When MirInputEvents are dispatched through a QML scene, not all of its information can be carried
        by QInputEvents. Some information is lost. Thus further on, if we want to transform a QInputEvent back into
--      its original MirInputEvent so that it can be consumed by a mir::scene::Surface, we have to reach out to
--      this EventRegistry to get the missing bits.
++      its original MirInputEvent so that it can be consumed by a mir::scene::Surface and properly handled by mir clients
++      we have to reach out to this EventRegistry to get the missing bits.
        Given the objective of this EventRegistry (MirInputEvent reconstruction after having gone through QQuickWindow input dispatch
        as a QInputEvent), it stores information only about the most recent MirInputEvents.
 === modified file 'src/platforms/mirserver/qteventfeeder.cpp'
 --- src/platforms/mirserver/qteventfeeder.cpp	2017-01-02 14:41:06 +0000
 +++ src/platforms/mirserver/qteventfeeder.cpp	2017-03-03 10:39:42 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2013-2016 Canonical, Ltd.
++ * Copyright (C) 2013-2017 Canonical, Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License version 3, as published by
@@ -598,9 +598,10 @@
  void QtEventFeeder::dispatchPointer(const MirPointerEvent *pev)
+ {
++    auto iev = mir_pointer_event_input_event(pev);
      auto timestamp = qtmir::compressTimestamp<qtmir::Timestamp>(
--                std::chrono::nanoseconds(mir_input_event_get_event_time(
--                                             mir_pointer_event_input_event(pev))));
++                std::chrono::nanoseconds(mir_input_event_get_event_time(iev)));
++    EventBuilder::instance()->store(iev, timestamp.count());
      auto action = mir_pointer_event_action(pev);
      qCDebug(QTMIR_MIR_INPUT) << "Received" << qPrintable(mirPointerEventToString(pev));
@@ -616,8 +617,6 @@
      case mir_pointer_action_button_down:
      case mir_pointer_action_motion:
+     {
--        EventBuilder::instance()->store(pev, timestamp.count());
--
          const float hDelta = mir_pointer_event_axis_value(pev, mir_pointer_axis_hscroll);
          const float vDelta = mir_pointer_event_axis_value(pev, mir_pointer_axis_vscroll);
@@ -637,9 +636,10 @@
  void QtEventFeeder::dispatchKey(const MirKeyboardEvent *kev)
+ {
++    auto iev = mir_keyboard_event_input_event(kev);
      auto timestamp = qtmir::compressTimestamp<qtmir::Timestamp>(
--                std::chrono::nanoseconds(mir_input_event_get_event_time(
--                                             mir_keyboard_event_input_event(kev))));
++                std::chrono::nanoseconds(mir_input_event_get_event_time(iev)));
++    EventBuilder::instance()->store(iev, timestamp.count());
      xkb_keysym_t xk_sym = mir_keyboard_event_key_code(kev);
@@ -687,9 +687,10 @@
  void QtEventFeeder::dispatchTouch(const MirTouchEvent *tev)
+ {
++    auto iev = mir_touch_event_input_event(tev);
      auto timestamp = qtmir::compressTimestamp<qtmir::Timestamp>(
--                std::chrono::nanoseconds(mir_input_event_get_event_time(
--                                             mir_touch_event_input_event(tev))));
++                std::chrono::nanoseconds(mir_input_event_get_event_time(iev)));
++    EventBuilder::instance()->store(iev, timestamp.count());
      tracepoint(qtmirserver, touchEventDispatch_start, std::chrono::nanoseconds(timestamp).count());
 === modified file 'tests/mirserver/EventBuilder/eventbuilder_test.cpp'
 --- tests/mirserver/EventBuilder/eventbuilder_test.cpp	2016-09-08 22:46:57 +0000
 +++ tests/mirserver/EventBuilder/eventbuilder_test.cpp	2017-03-03 10:39:42 +0000
@@ -1,5 +1,5 @@
  /*
-- * Copyright (C) 2016 Canonical, Ltd.
++ * Copyright (C) 2016-2017 Canonical, Ltd.
+  *
   * This program is free software: you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License version 3, as published by
@@ -21,6 +21,7 @@
  #include <QScopedPointer>
  #include "mir/events/event_builders.h"
++#include "mir_toolkit/mir_cookie.h"
  using namespace qtmir;
@@ -48,7 +49,7 @@
                  std::vector<uint8_t>{} /* cookie */, mir_input_event_modifier_none, mir_pointer_action_motion, 0 /*buttons*/,
 /*x*/, 0 /*y*/, 0 /*hscroll*/, 0 /*vscroll*/, relativeX, relativeY);
--        eventBuilder->store(mir_input_event_get_pointer_event(mir_event_get_input_event(mirEvent.get())), qtTimestamp);
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp);
+     }
      // And store some other unrelated events in between
@@ -56,13 +57,13 @@
          mir::EventUPtr mirEvent = mir::events::make_event(0 /*DeviceID */, std::chrono::nanoseconds(222)/*timestamp*/,
              std::vector<uint8_t>{} /* cookie */, mir_input_event_modifier_none, mir_pointer_action_motion, 0 /*buttons*/,
 /*x*/, 0 /*y*/, 0 /*hscroll*/, 0 /*vscroll*/, relativeX + 3.3, relativeY + 3.3);
--        eventBuilder->store(mir_input_event_get_pointer_event(mir_event_get_input_event(mirEvent.get())), qtTimestamp + 10);
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp + 10);
+     }
+     {
          mir::EventUPtr mirEvent = mir::events::make_event(0 /*DeviceID */, std::chrono::nanoseconds(333)/*timestamp*/,
              std::vector<uint8_t>{} /* cookie */, mir_input_event_modifier_none, mir_pointer_action_motion, 0 /*buttons*/,
 /*x*/, 0 /*y*/, 0 /*hscroll*/, 0 /*vscroll*/, relativeX + 4.4, relativeY + 4.4);
--        eventBuilder->store(mir_input_event_get_pointer_event(mir_event_get_input_event(mirEvent.get())), qtTimestamp + 20);
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp + 20);
+     }
      QMouseEvent mouseEvent(QEvent::MouseMove, QPointF(0,0) /*localPos*/, Qt::NoButton, Qt::NoButton, Qt::NoModifier);
@@ -75,3 +76,83 @@
      EXPECT_EQ(relativeX, mir_pointer_event_axis_value(newMirPointerEvent, mir_pointer_axis_relative_x));
      EXPECT_EQ(relativeY, mir_pointer_event_axis_value(newMirPointerEvent, mir_pointer_axis_relative_y));
+ }
++
++TEST_F(EventBuilderTest, ReconstructCookies)
++{
++    QScopedPointer<EventBuilder> eventBuilder(new EventBuilder);
++
++    std::vector<uint8_t> cookie{0xd7, 0x56, 0xf1, 0xb7, 0xd8, 0xba};
++
++    ulong qtTimestamp = 12345;
++
++    // Store the event whose data we will get later when reconstructing it.
++    {
++        mir::EventUPtr mirEvent = mir::events::make_event(0 /*DeviceID */, std::chrono::nanoseconds(111)/*timestamp*/,
++                cookie, mir_input_event_modifier_none, mir_pointer_action_button_down, mir_pointer_button_primary/*buttons*/,
++                0 /*x*/, 0 /*y*/, 0 /*hscroll*/, 0 /*vscroll*/, 0 /*relativeX*/, 0 /*relativeY*/);
++
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp);
++    }
++
++    // And store some other unrelated events in between
++    {
++        mir::EventUPtr mirEvent = mir::events::make_event(0 /*DeviceID */, std::chrono::nanoseconds(222)/*timestamp*/,
++            std::vector<uint8_t>{} /* cookie */, mir_input_event_modifier_none, mir_pointer_action_motion, 0 /*buttons*/,
++            0 /*x*/, 0 /*y*/, 0 /*hscroll*/, 0 /*vscroll*/, 0 /*relativeX*/, 0 /*relativeY*/);
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp + 10);
++    }
++    {
++        mir::EventUPtr mirEvent = mir::events::make_event(0 /*DeviceID */, std::chrono::nanoseconds(333)/*timestamp*/,
++            std::vector<uint8_t>{} /* cookie */, mir_input_event_modifier_none, mir_pointer_action_motion, 0 /*buttons*/,
++            0 /*x*/, 0 /*y*/, 0 /*hscroll*/, 0 /*vscroll*/, 0 /*relativeX*/, 0 /*relativeY*/);
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp + 20);
++    }
++
++    QMouseEvent mouseEvent(QEvent::MouseMove, QPointF(0,0) /*localPos*/, Qt::NoButton, Qt::NoButton, Qt::NoModifier);
++    mouseEvent.setTimestamp(qtTimestamp); // this is what identifies this Qt event with the first Mir event stored.
++
++    mir::EventUPtr newMirEvent = eventBuilder->reconstructMirEvent(&mouseEvent);
++
++    // The reconstructed event should have the same relative axes values as the mir event stored with the same timestamp
++    auto input_event = mir_event_get_input_event(newMirEvent.get());
++    auto cookie_ptr = mir_input_event_get_cookie(input_event);
++    std::vector<uint8_t> cookieFromPointerEvent;
++    cookieFromPointerEvent.resize(mir_cookie_buffer_size(cookie_ptr));
++    mir_cookie_to_buffer(cookie_ptr, cookieFromPointerEvent.data(), cookieFromPointerEvent.size());
++    mir_cookie_release(cookie_ptr);
++    EXPECT_EQ(cookieFromPointerEvent, cookie);
++}
++
++TEST_F(EventBuilderTest, ReconstructDeviceId)
++{
++    QScopedPointer<EventBuilder> eventBuilder(new EventBuilder);
++
++    MirInputDeviceId deviceId = 17;
++    ulong qtTimestamp = 12345;
++
++    // Store the event whose data we will get later when reconstructing it.
++    {
++        mir::EventUPtr mirEvent = mir::events::make_event(deviceId, std::chrono::nanoseconds(111)/*timestamp*/,
++                std::vector<uint8_t>{}/*cookie*/, mir_keyboard_action_down, 70, 50,
++                mir_input_event_modifier_none);
++
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp);
++    }
++
++    // And store some other unrelated events in between
++    {
++        mir::EventUPtr mirEvent = mir::events::make_event(0 /*DeviceID */, std::chrono::nanoseconds(222)/*timestamp*/,
++            std::vector<uint8_t>{} /* cookie */, mir_input_event_modifier_none, mir_pointer_action_motion, 0 /*buttons*/,
++            0 /*x*/, 0 /*y*/, 0 /*hscroll*/, 0 /*vscroll*/, 0 /*relativeX*/,0 /*relativeY*/);
++        eventBuilder->store(mir_event_get_input_event(mirEvent.get()), qtTimestamp + 10);
++    }
++
++    QKeyEvent keyEvent(QEvent::KeyPress, 70, Qt::NoModifier);
++    keyEvent.setTimestamp(qtTimestamp); // this is what identifies this Qt event with the first Mir event stored.
++
++    mir::EventUPtr newMirEvent = eventBuilder->makeMirEvent(&keyEvent);
++
++    // The reconstructed event should have the same relative axes values as the mir event stored with the same timestamp
++    auto input_event = mir_event_get_input_event(newMirEvent.get());
++    EXPECT_EQ(deviceId, mir_input_event_get_device_id(input_event));
++}