Handle fallout from QEvent loosing it's copy constructor

Task-number: QTBUG-88757
Change-Id: I5097faecd2e895d4685a4cc57a4e2a5c079f2255
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>
(cherry picked from commit d826238b65b0ebd8034900224b382bd85e6add27)
Reviewed-by: Qt Cherry-pick Bot <cherrypick_bot@qt-project.org>

14 files changed, 714 insertions, 656 deletions

diff --git a/dependencies.yaml b/dependencies.yaml
index ec2ba8464..575293038 100644
--- a/dependencies.yaml
+++ b/dependencies.yaml
@@ -1,10 +1,10 @@
 dependencies:
   ../qtbase:
-    ref: 7fbfa4441b29afaa1ab9866d7f59c289ce4cfcbf
+    ref: 06f58a909bcdcd08d125f5decd1fba894c285765
     required: true
   ../qtdeclarative:
-    ref: a8122590058e57a340a42eab0a34010a3a3c5271
-    required: false
+    ref: 861d93965e0dbc2c088e83f8a6093a639373a02c
+    required: true
   ../qtshadertools:
-    ref: 181ad749a0722194cfbd0c634ed0ca63c5dae689
-    required: false
+    ref: 72f0fc613242b57d4402d401ce80d758915b0f94
+    required: true
diff --git a/src/animation/frontend/qanimationclipdata.h b/src/animation/frontend/qanimationclipdata.h
index 07c7d92c2..bcb0fcda1 100644
--- a/src/animation/frontend/qanimationclipdata.h
+++ b/src/animation/frontend/qanimationclipdata.h
@@ -40,6 +40,7 @@
 #ifndef QT3DANIMATION_QANIMATIONCLIPDATA_H
 #define QT3DANIMATION_QANIMATIONCLIPDATA_H
 
+#include <QtCore/qmetatype.h>
 #include <QtCore/qscopedpointer.h>
 #include <QtCore/qstring.h>
 #include <Qt3DAnimation/qt3danimation_global.h>
diff --git a/src/input/frontend/qkeyevent.cpp b/src/input/frontend/qkeyevent.cpp
index efbddc771..07319ea53 100644
--- a/src/input/frontend/qkeyevent.cpp
+++ b/src/input/frontend/qkeyevent.cpp
@@ -74,16 +74,16 @@ namespace Qt3DInput {
 
 QKeyEvent::QKeyEvent(QEvent::Type type, int key, Qt::KeyboardModifiers modifiers, const QString &text, bool autorep, ushort count)
     : QObject()
-    , m_event(type, key, modifiers, text, autorep, count)
+      , m_event(new QT_PREPEND_NAMESPACE(QKeyEvent){type, key, modifiers, text, autorep, count})
 {
-    m_event.setAccepted(false);
+    m_event->setAccepted(false);
 }
 
 QKeyEvent::QKeyEvent(const QT_PREPEND_NAMESPACE(QKeyEvent) &ke)
     : QObject()
-    , m_event(ke)
+    , m_event(static_cast<QT_PREPEND_NAMESPACE(QKeyEvent) *>(ke.clone()))
 {
-    m_event.setAccepted(false);
+    m_event->setAccepted(false);
 }
 
 /*! \internal */
diff --git a/src/input/frontend/qkeyevent.h b/src/input/frontend/qkeyevent.h
index c1e221aae..52be3b213 100644
--- a/src/input/frontend/qkeyevent.h
+++ b/src/input/frontend/qkeyevent.h
@@ -69,21 +69,21 @@ public:
     explicit QKeyEvent(const QT_PREPEND_NAMESPACE(QKeyEvent) &ke);
     ~QKeyEvent();
 
-    inline int key() const { return m_event.key(); }
-    inline QString text() const { return m_event.text(); }
-    inline int modifiers() const { return m_event.modifiers(); }
-    inline bool isAutoRepeat() const { return m_event.isAutoRepeat(); }
-    inline int count() const { return m_event.count(); }
-    inline quint32 nativeScanCode() const { return m_event.nativeScanCode(); }
-    inline bool isAccepted() const { return m_event.isAccepted(); }
-    inline void setAccepted(bool accepted) { m_event.setAccepted(accepted); }
-    inline QEvent::Type type() const { return m_event.type(); }
+    inline int key() const { return m_event->key(); }
+    inline QString text() const { return m_event->text(); }
+    inline int modifiers() const { return m_event->modifiers(); }
+    inline bool isAutoRepeat() const { return m_event->isAutoRepeat(); }
+    inline int count() const { return m_event->count(); }
+    inline quint32 nativeScanCode() const { return m_event->nativeScanCode(); }
+    inline bool isAccepted() const { return m_event->isAccepted(); }
+    inline void setAccepted(bool accepted) { m_event->setAccepted(accepted); }
+    inline QEvent::Type type() const { return m_event->type(); }
 #if QT_CONFIG(shortcut)
-    Q_INVOKABLE bool matches(QKeySequence::StandardKey key_) const { return m_event.matches(key_); }
+    Q_INVOKABLE bool matches(QKeySequence::StandardKey key_) const { return m_event->matches(key_); }
 #endif
 
 private:
-    QT_PREPEND_NAMESPACE(QKeyEvent) m_event;
+    std::unique_ptr<QT_PREPEND_NAMESPACE(QKeyEvent)> m_event;
 };
 
 } // namespace Qt3DInput
diff --git a/src/input/frontend/qmouseevent.cpp b/src/input/frontend/qmouseevent.cpp
index 2b06c824d..d73724360 100644
--- a/src/input/frontend/qmouseevent.cpp
+++ b/src/input/frontend/qmouseevent.cpp
@@ -46,9 +46,9 @@ namespace Qt3DInput {
 namespace {
 
 template<typename EventClass, typename QtEventClass>
-typename EventClass::Modifiers modifiersForEvent(const QtEventClass &event)
+typename EventClass::Modifiers modifiersForEvent(const QtEventClass *event)
 {
-    const Qt::KeyboardModifiers eventModifiers = event.modifiers();
+    const Qt::KeyboardModifiers eventModifiers = event->modifiers();
     int modifiers = EventClass::NoModifier;
 
     if (eventModifiers & Qt::ShiftModifier)
@@ -259,7 +259,11 @@ typename EventClass::Modifiers modifiersForEvent(const QtEventClass &event)
  */
 QMouseEvent::QMouseEvent(const QT_PREPEND_NAMESPACE(QMouseEvent) &e)
     : QObject()
-    , m_event(e)
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+      , m_event(static_cast<QT_PREPEND_NAMESPACE(QMouseEvent)*>(e.clone()))
+#else
+    , m_even(new QT_PREPEND_NAMESPACE(QMouseEvent)(e))
+#endif
 {
 }
 
@@ -272,7 +276,7 @@ QMouseEvent::~QMouseEvent()
  */
 QMouseEvent::Buttons QMouseEvent::button() const
 {
-    switch (m_event.button()) {
+    switch (m_event->button()) {
     case Qt::LeftButton:
         return QMouseEvent::LeftButton;
     case Qt::RightButton:
@@ -292,7 +296,7 @@ QMouseEvent::Buttons QMouseEvent::button() const
  */
 int QMouseEvent::buttons() const
 {
-   return m_event.buttons();
+    return m_event->buttons();
 }
 
 /*!
@@ -300,7 +304,7 @@ int QMouseEvent::buttons() const
  */
 QMouseEvent::Modifiers QMouseEvent::modifiers() const
 {
-    return modifiersForEvent<QMouseEvent, decltype(m_event)>(m_event);
+    return modifiersForEvent<QMouseEvent, QT_PREPEND_NAMESPACE(QMouseEvent)>(m_event.get());
 }
 
 /*!
@@ -478,7 +482,11 @@ QMouseEvent::Modifiers QMouseEvent::modifiers() const
  */
 QWheelEvent::QWheelEvent(const QT_PREPEND_NAMESPACE(QWheelEvent) &e)
     : QObject()
-    , m_event(e)
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+      , m_event(static_cast<QT_PREPEND_NAMESPACE(QWheelEvent)*>(e.clone()))
+#else
+      , m_even(new QT_PREPEND_NAMESPACE(QMouseEvent)(e))
+#endif
 {
 }
 
@@ -492,7 +500,7 @@ QWheelEvent::~QWheelEvent()
  */
 int QWheelEvent::buttons() const
 {
-    return m_event.buttons();
+    return m_event->buttons();
 }
 
 /*!
@@ -500,7 +508,7 @@ int QWheelEvent::buttons() const
  */
 QWheelEvent::Modifiers QWheelEvent::modifiers() const
 {
-    return modifiersForEvent<QWheelEvent, decltype(m_event)>(m_event);
+    return modifiersForEvent<QWheelEvent, QT_PREPEND_NAMESPACE(QWheelEvent)>(m_event.get());
 }
 #endif // QT_CONFIG(wheelevent)
 
diff --git a/src/input/frontend/qmouseevent.h b/src/input/frontend/qmouseevent.h
index a663c2e44..809c71ec5 100644
--- a/src/input/frontend/qmouseevent.h
+++ b/src/input/frontend/qmouseevent.h
@@ -45,6 +45,8 @@
 #include <QtCore/QObject>
 #include <QtGui/QMouseEvent>
 
+#include <memory>
+
 QT_BEGIN_NAMESPACE
 
 namespace Qt3DInput {
@@ -59,7 +61,6 @@ class Q_3DINPUTSHARED_EXPORT QMouseEvent : public QObject
     Q_PROPERTY(int buttons READ buttons CONSTANT)
     Q_PROPERTY(Qt3DInput::QMouseEvent::Modifiers modifiers READ modifiers CONSTANT)
     Q_PROPERTY(bool accepted READ isAccepted WRITE setAccepted)
-
 public:
     enum Buttons {
         LeftButton = Qt::LeftButton,
@@ -84,25 +85,25 @@ public:
     explicit QMouseEvent(const QT_PREPEND_NAMESPACE(QMouseEvent) &e);
     ~QMouseEvent();
 
-    inline int x() const { return int(m_event.position().x()); }
-    inline int y() const { return int(m_event.position().y()); }
+    inline int x() const { return int(m_event->position().x()); }
+    inline int y() const { return int(m_event->position().y()); }
     inline bool wasHeld() const {
 #if QT_CONFIG(gestures)
-      return static_cast<Qt::GestureType>(m_event.type()) == Qt::TapAndHoldGesture;
+        return static_cast<Qt::GestureType>(m_event->type()) == Qt::TapAndHoldGesture;
 #else
-      return false;
+        return false;
 #endif
     }
     Buttons button() const;
     int buttons() const;
     Modifiers modifiers() const;
 
-    inline bool isAccepted() const { return m_event.isAccepted(); }
-    inline void setAccepted(bool accepted) { m_event.setAccepted(accepted); }
-    inline QEvent::Type type() const { return m_event.type(); }
+    inline bool isAccepted() const { return m_event->isAccepted(); }
+    inline void setAccepted(bool accepted) { m_event->setAccepted(accepted); }
+    inline QEvent::Type type() const { return m_event->type(); }
 
 private:
-    QT_PREPEND_NAMESPACE(QMouseEvent) m_event;
+    std::unique_ptr<QT_PREPEND_NAMESPACE(QMouseEvent)> m_event;
 };
 
 typedef QSharedPointer<QMouseEvent> QMouseEventPtr;
@@ -142,18 +143,18 @@ public:
     explicit QWheelEvent(const QT_PREPEND_NAMESPACE(QWheelEvent) &e);
     ~QWheelEvent();
 
-    inline int x() const { return int(m_event.position().x()); }
-    inline int y() const { return int(m_event.position().y()); }
-    inline QPoint angleDelta() const { return m_event.angleDelta(); }
+    inline int x() const { return int(m_event->position().x()); }
+    inline int y() const { return int(m_event->position().y()); }
+    inline QPoint angleDelta() const { return m_event->angleDelta(); }
     int buttons() const;
     Modifiers modifiers() const;
 
-    inline bool isAccepted() const { return m_event.isAccepted(); }
-    inline void setAccepted(bool accepted) { m_event.setAccepted(accepted); }
-    inline QEvent::Type type() const { return m_event.type(); }
+    inline bool isAccepted() const { return m_event->isAccepted(); }
+    inline void setAccepted(bool accepted) { m_event->setAccepted(accepted); }
+    inline QEvent::Type type() const { return m_event->type(); }
 
 private:
-    QT_PREPEND_NAMESPACE(QWheelEvent) m_event;
+    std::unique_ptr<QT_PREPEND_NAMESPACE(QWheelEvent)> m_event;
 };
 
 typedef QSharedPointer<QWheelEvent> QWheelEventPtr;
diff --git a/src/plugins/renderers/opengl/renderer/renderer.cpp b/src/plugins/renderers/opengl/renderer/renderer.cpp
index 26b2b0ed8..91bf77fa9 100644
--- a/src/plugins/renderers/opengl/renderer/renderer.cpp
+++ b/src/plugins/renderers/opengl/renderer/renderer.cpp
@@ -1639,12 +1639,6 @@ Renderer::ViewSubmissionResultData Renderer::submitRenderViews(const std::vector
                     m_imGuiRenderer->setCapabilities(m_settings->capabilities());
             }
 
-            {
-                for (auto &keyEvent: m_frameKeyEvents)
-                    m_imGuiRenderer->processEvent(&keyEvent);
-                for (auto &mouseEvent: m_frameMouseEvents)
-                    m_imGuiRenderer->processEvent(&mouseEvent.second);
-            }
             m_imGuiRenderer->renderDebugOverlay(renderViews, renderView, m_jobsInLastFrame);
         }
 #endif
diff --git a/src/plugins/renderers/opengl/renderer/renderer_p.h b/src/plugins/renderers/opengl/renderer/renderer_p.h
index 4e4b7a28a..aedd49b49 100644
--- a/src/plugins/renderers/opengl/renderer/renderer_p.h
+++ b/src/plugins/renderers/opengl/renderer/renderer_p.h
@@ -419,8 +419,6 @@ private:
     QSharedPointer<ResourceAccessor> m_scene2DResourceAccessor;
 
     Debug::ImGuiRenderer *m_imGuiRenderer;
-    QList<QPair<QObject *, QMouseEvent>> m_frameMouseEvents;
-    QList<QKeyEvent> m_frameKeyEvents;
     int m_jobsInLastFrame;
 };
 
diff --git a/src/render/jobs/pickboundingvolumejob.cpp b/src/render/jobs/pickboundingvolumejob.cpp
index e0f4c8bf0..2420ce439 100644
--- a/src/render/jobs/pickboundingvolumejob.cpp
+++ b/src/render/jobs/pickboundingvolumejob.cpp
@@ -211,7 +211,11 @@ void PickBoundingVolumeJob::setRoot(Entity *root)
 
 bool PickBoundingVolumeJob::processMouseEvent(QObject* object, QMouseEvent *event)
 {
-    m_pendingMouseEvents.emplace_back(object, QMouseEvent(*event));
+#if QT_VERSION >= QT_VERSION_CHECK(6, 0, 0)
+    m_pendingMouseEvents.emplace_back(object, std::unique_ptr<QMouseEvent>(static_cast<QMouseEvent *>(event->clone())));
+#else
+    m_pendingMouseEvents.emplace_back(object, new QMouseEvent(*event));
+#endif
     return false;
 }
 
@@ -254,7 +258,7 @@ bool PickBoundingVolumeJob::runHelper()
     bool hasOtherEvent = false;
     // Quickly look which types of events we've got
     for (const auto &event : mouseEvents) {
-        const bool isMove = (event.second.type() == QEvent::MouseMove);
+        const bool isMove = (event.second->type() == QEvent::MouseMove);
         hasMoveEvent |= isMove;
         hasOtherEvent |= !isMove;
     }
@@ -290,7 +294,7 @@ bool PickBoundingVolumeJob::runHelper()
 
     // For each mouse event
     for (const auto &event : mouseEvents)
-        processPickEvent(pickConfiguration, event.first, &event.second);
+        processPickEvent(pickConfiguration, event.first, event.second.get());
 
     // Clear Hovered elements that needs to be cleared
     // Send exit event to object pickers on which we
diff --git a/src/render/jobs/pickboundingvolumejob_p.h b/src/render/jobs/pickboundingvolumejob_p.h
index daf66583f..f95d4f773 100644
--- a/src/render/jobs/pickboundingvolumejob_p.h
+++ b/src/render/jobs/pickboundingvolumejob_p.h
@@ -65,6 +65,7 @@
 #include <QSharedPointer>
 
 #include <vector>
+#include <memory>
 
 QT_BEGIN_NAMESPACE
 
@@ -109,7 +110,7 @@ private:
 
     void clearPreviouslyHoveredPickers();
 
-    std::vector<std::pair<QObject*, QMouseEvent>> m_pendingMouseEvents;
+    std::vector<std::pair<QObject*, std::unique_ptr<QMouseEvent>>> m_pendingMouseEvents;
     bool m_pickersDirty;
     bool m_oneHoverAtLeast;
     HObjectPicker m_currentPicker;
diff --git a/src/render/picking/pickeventfilter.cpp b/src/render/picking/pickeventfilter.cpp
index 42e26dbae..998829b34 100644
--- a/src/render/picking/pickeventfilter.cpp
+++ b/src/render/picking/pickeventfilter.cpp
@@ -60,25 +60,6 @@ PickEventFilter::~PickEventFilter()
 
 /*!
     \internal
-    Called from a worker thread in the thread pool so be sure to
-    mutex protect the data.
-*/
-QList<QPair<QObject *, QMouseEvent> > PickEventFilter::pendingMouseEvents()
-{
-    QList<QPair<QObject*, QMouseEvent>> pendingEvents(m_pendingMouseEvents);
-    m_pendingMouseEvents.clear();
-    return pendingEvents;
-}
-
-QList<QKeyEvent> PickEventFilter::pendingKeyEvents()
-{
-    QList<QKeyEvent> pendingEvents(m_pendingKeyEvents);
-    m_pendingKeyEvents.clear();
-    return pendingEvents;
-}
-
-/*!
-    \internal
     Called from the main thread.
 */
 bool PickEventFilter::eventFilter(QObject *obj, QEvent *e)
@@ -87,19 +68,16 @@ bool PickEventFilter::eventFilter(QObject *obj, QEvent *e)
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseMove:
-        m_pendingMouseEvents.push_back({obj, QMouseEvent(*static_cast<QMouseEvent *>(e))});
         return m_aspect->processMouseEvent(obj, static_cast<QMouseEvent *>(e));
     case QEvent::HoverMove: {
         QHoverEvent *he = static_cast<QHoverEvent *>(e);
         auto mouseEvent = QMouseEvent(QEvent::MouseMove,
                                       he->position(), Qt::NoButton, Qt::NoButton,
                                       he->modifiers());
-        m_pendingMouseEvents.push_back({obj, mouseEvent});
         return m_aspect->processMouseEvent(obj, &mouseEvent);
         }
     case QEvent::KeyPress:
     case QEvent::KeyRelease:
-        m_pendingKeyEvents.push_back(QKeyEvent(*static_cast<QKeyEvent *>(e)));
         return m_aspect->processKeyEvent(obj, static_cast<QKeyEvent *>(e));
     default:
         break;
diff --git a/src/render/picking/pickeventfilter_p.h b/src/render/picking/pickeventfilter_p.h
index 85fcf454a..67752458b 100644
--- a/src/render/picking/pickeventfilter_p.h
+++ b/src/render/picking/pickeventfilter_p.h
@@ -72,16 +72,11 @@ public:
     explicit PickEventFilter(QRenderAspectPrivate *aspect, QObject *parent = nullptr);
     ~PickEventFilter();
 
-    QList<QPair<QObject*, QMouseEvent>> pendingMouseEvents();
-    QList<QKeyEvent> pendingKeyEvents();
-
 protected:
     bool eventFilter(QObject *obj, QEvent *e) final;
 
 private:
     QRenderAspectPrivate *m_aspect;
-    QList<QPair<QObject*, QMouseEvent>> m_pendingMouseEvents;
-    QList<QKeyEvent> m_pendingKeyEvents;
 };
 
 } // Render
diff --git a/tests/auto/input/mousedevice/tst_mousedevice.cpp b/tests/auto/input/mousedevice/tst_mousedevice.cpp
index 027866196..2669daa89 100644
--- a/tests/auto/input/mousedevice/tst_mousedevice.cpp
+++ b/tests/auto/input/mousedevice/tst_mousedevice.cpp
@@ -105,129 +105,139 @@ private Q_SLOTS:
         // GIVEN
         Qt3DInput::Input::MouseDevice backendMouseDevice;
 
-        // WHEN
-        auto event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseButtonPress,
-                                                       QPointF(400.0, 400.0),
-                                                       QPointF(400.0, 400.0),
-                                                       QPointF(400.0, 400.0),
-                                                       Qt::LeftButton,
-                                                       Qt::LeftButton,
-                                                       Qt::NoModifier);
-        backendMouseDevice.resetMouseAxisState();
-        backendMouseDevice.updateMouseEvent(&event);
-
-        // THEN
-        // Note: axis are only modified when moving (> 1 event)
-        QCOMPARE(backendMouseDevice.mouseState().xAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().yAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().leftPressed, true);
-        QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
-        QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
-        QCOMPARE(backendMouseDevice.previousPos(), QPointF(400.0, 400.0));
-        QCOMPARE(backendMouseDevice.wasPressed(), true);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
-        QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseButtonPress,
+                                                           QPointF(400.0, 400.0),
+                                                           QPointF(400.0, 400.0),
+                                                           QPointF(400.0, 400.0),
+                                                           Qt::LeftButton,
+                                                           Qt::LeftButton,
+                                                           Qt::NoModifier);
+            backendMouseDevice.resetMouseAxisState();
+            backendMouseDevice.updateMouseEvent(&event);
 
-        // WHEN
-        event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseMove,
-                                                  QPointF(600.0, 600.0),
-                                                  QPointF(600.0, 600.0),
-                                                  QPointF(600.0, 600.0),
-                                                  Qt::LeftButton,
-                                                  Qt::LeftButton,
-                                                  Qt::NoModifier);
-        backendMouseDevice.resetMouseAxisState();
-        backendMouseDevice.updateMouseEvent(&event);
+            // THEN
+            // Note: axis are only modified when moving (> 1 event)
+            QCOMPARE(backendMouseDevice.mouseState().xAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().yAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().leftPressed, true);
+            QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
+            QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
+            QCOMPARE(backendMouseDevice.previousPos(), QPointF(400.0, 400.0));
+            QCOMPARE(backendMouseDevice.wasPressed(), true);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+        }
 
-        // THEN
-        QCOMPARE(backendMouseDevice.mouseState().xAxis, (600.0f - 400.0f) * 0.1f);
-        QCOMPARE(backendMouseDevice.mouseState().yAxis, (400.0f - 600.0f) * 0.1f);
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().leftPressed, true);
-        QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
-        QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
-        QCOMPARE(backendMouseDevice.previousPos(), QPointF(600.0, 600.0));
-        QCOMPARE(backendMouseDevice.wasPressed(), true);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
-        QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseMove,
+                                                           QPointF(600.0, 600.0),
+                                                           QPointF(600.0, 600.0),
+                                                           QPointF(600.0, 600.0),
+                                                           Qt::LeftButton,
+                                                           Qt::LeftButton,
+                                                           Qt::NoModifier);
+            backendMouseDevice.resetMouseAxisState();
+            backendMouseDevice.updateMouseEvent(&event);
 
-        // WHEN
-        event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseButtonRelease,
-                                                  QPointF(800.0, 800.0),
-                                                  QPointF(800.0, 800.0),
-                                                  QPointF(800.0, 800.0),
-                                                  Qt::LeftButton,
-                                                  Qt::NoButton,
-                                                  Qt::NoModifier);
-        backendMouseDevice.resetMouseAxisState();
-        backendMouseDevice.updateMouseEvent(&event);
+            // THEN
+            QCOMPARE(backendMouseDevice.mouseState().xAxis, (600.0f - 400.0f) * 0.1f);
+            QCOMPARE(backendMouseDevice.mouseState().yAxis, (400.0f - 600.0f) * 0.1f);
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().leftPressed, true);
+            QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
+            QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
+            QCOMPARE(backendMouseDevice.previousPos(), QPointF(600.0, 600.0));
+            QCOMPARE(backendMouseDevice.wasPressed(), true);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+        }
 
-        // THEN
-        QCOMPARE(backendMouseDevice.mouseState().xAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().yAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().leftPressed, false);
-        QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
-        QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
-        QCOMPARE(backendMouseDevice.previousPos(), QPointF(800.0, 800.0));
-        QCOMPARE(backendMouseDevice.wasPressed(), false);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
-        QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseButtonRelease,
+                                                           QPointF(800.0, 800.0),
+                                                           QPointF(800.0, 800.0),
+                                                           QPointF(800.0, 800.0),
+                                                           Qt::LeftButton,
+                                                           Qt::NoButton,
+                                                           Qt::NoModifier);
+            backendMouseDevice.resetMouseAxisState();
+            backendMouseDevice.updateMouseEvent(&event);
 
-        // WHEN
-        event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseMove,
-                                                  QPointF(900.0, 900.0),
-                                                  QPointF(900.0, 900.0),
-                                                  QPointF(900.0, 900.0),
-                                                  Qt::NoButton,
-                                                  Qt::NoButton,
-                                                  Qt::NoModifier);
-
-        // THEN -> no axes update
-        backendMouseDevice.updateMouseEvent(&event);
-        QCOMPARE(backendMouseDevice.mouseState().xAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().yAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().leftPressed, false);
-        QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
-        QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
-        QCOMPARE(backendMouseDevice.previousPos(), QPointF(900.0, 900.0));
-        QCOMPARE(backendMouseDevice.wasPressed(), false);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
-        QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+            // THEN
+            QCOMPARE(backendMouseDevice.mouseState().xAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().yAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().leftPressed, false);
+            QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
+            QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
+            QCOMPARE(backendMouseDevice.previousPos(), QPointF(800.0, 800.0));
+            QCOMPARE(backendMouseDevice.wasPressed(), false);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+        }
 
-        // WHEN
-        event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseMove,
-                                                  QPointF(1000.0, 1000.0),
-                                                  QPointF(1000.0, 1000.0),
-                                                  QPointF(1000.0, 1000.0),
-                                                  Qt::NoButton,
-                                                  Qt::NoButton,
-                                                  Qt::NoModifier);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseMove,
+                                                           QPointF(900.0, 900.0),
+                                                           QPointF(900.0, 900.0),
+                                                           QPointF(900.0, 900.0),
+                                                           Qt::NoButton,
+                                                           Qt::NoButton,
+                                                           Qt::NoModifier);
+
+            // THEN -> no axes update
+            backendMouseDevice.updateMouseEvent(&event);
+            QCOMPARE(backendMouseDevice.mouseState().xAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().yAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().leftPressed, false);
+            QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
+            QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
+            QCOMPARE(backendMouseDevice.previousPos(), QPointF(900.0, 900.0));
+            QCOMPARE(backendMouseDevice.wasPressed(), false);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            QCOMPARE(backendMouseDevice.updateAxesContinuously(), false);
+        }
 
-        Qt3DInput::QMouseDevice mouseDevice;
-        mouseDevice.setUpdateAxesContinuously(true);
-        backendMouseDevice.syncFromFrontEnd(&mouseDevice, false);
-        backendMouseDevice.resetMouseAxisState();
-        backendMouseDevice.updateMouseEvent(&event);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QMouseEvent)(QMouseEvent::MouseMove,
+                                                           QPointF(1000.0, 1000.0),
+                                                           QPointF(1000.0, 1000.0),
+                                                           QPointF(1000.0, 1000.0),
+                                                           Qt::NoButton,
+                                                           Qt::NoButton,
+                                                           Qt::NoModifier);
+
+            Qt3DInput::QMouseDevice mouseDevice;
+            mouseDevice.setUpdateAxesContinuously(true);
+            backendMouseDevice.syncFromFrontEnd(&mouseDevice, false);
+            backendMouseDevice.resetMouseAxisState();
+            backendMouseDevice.updateMouseEvent(&event);
 
-        // THEN
-        QCOMPARE(backendMouseDevice.mouseState().xAxis, (1000.0f - 900.0f) * 0.1f);
-        QCOMPARE(backendMouseDevice.mouseState().yAxis, (900.0f - 1000.0f) * 0.1f);
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().leftPressed,false);
-        QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
-        QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
-        QCOMPARE(backendMouseDevice.previousPos(), QPointF(1000.0, 1000.0));
-        QCOMPARE(backendMouseDevice.wasPressed(), false);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
-        QCOMPARE(backendMouseDevice.updateAxesContinuously(), true);
+            // THEN
+            QCOMPARE(backendMouseDevice.mouseState().xAxis, (1000.0f - 900.0f) * 0.1f);
+            QCOMPARE(backendMouseDevice.mouseState().yAxis, (900.0f - 1000.0f) * 0.1f);
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().leftPressed,false);
+            QCOMPARE(backendMouseDevice.mouseState().rightPressed, false);
+            QCOMPARE(backendMouseDevice.mouseState().centerPressed, false);
+            QCOMPARE(backendMouseDevice.previousPos(), QPointF(1000.0, 1000.0));
+            QCOMPARE(backendMouseDevice.wasPressed(), false);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            QCOMPARE(backendMouseDevice.updateAxesContinuously(), true);
+        }
     }
 
 #if QT_CONFIG(wheelevent)
@@ -236,52 +246,58 @@ private Q_SLOTS:
         // GIVEN
         Qt3DInput::Input::MouseDevice backendMouseDevice;
 
-        // WHEN
-        auto event = QT_PREPEND_NAMESPACE(QWheelEvent)(QPointF(500.0, 500.0),
-                                                       QPointF(), QPoint(),
-                                                       QPoint(0, 120),
-                                                       Qt::NoButton,
-                                                       Qt::NoModifier,
-                                                       Qt::NoScrollPhase,
-                                                       false);
-        backendMouseDevice.resetMouseAxisState();
-        backendMouseDevice.updateWheelEvent(&event);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QWheelEvent)(QPointF(500.0, 500.0),
+                                                           QPointF(), QPoint(),
+                                                           QPoint(0, 120),
+                                                           Qt::NoButton,
+                                                           Qt::NoModifier,
+                                                           Qt::NoScrollPhase,
+                                                           false);
+            backendMouseDevice.resetMouseAxisState();
+            backendMouseDevice.updateWheelEvent(&event);
 
-        // THEN
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.1f * 120);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            // THEN
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.1f * 120);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+        }
 
-        // WHEN
-        event = QT_PREPEND_NAMESPACE(QWheelEvent)(QPointF(500.0, 500.0),
-                                                  QPointF(), QPoint(),
-                                                  QPoint(120, 0),
-                                                  Qt::NoButton,
-                                                  Qt::NoModifier,
-                                                  Qt::NoScrollPhase,
-                                                  false);
-        backendMouseDevice.resetMouseAxisState();
-        backendMouseDevice.updateWheelEvent(&event);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QWheelEvent)(QPointF(500.0, 500.0),
+                                                           QPointF(), QPoint(),
+                                                           QPoint(120, 0),
+                                                           Qt::NoButton,
+                                                           Qt::NoModifier,
+                                                           Qt::NoScrollPhase,
+                                                           false);
+            backendMouseDevice.resetMouseAxisState();
+            backendMouseDevice.updateWheelEvent(&event);
 
-        // THEN
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.1f * 120);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            // THEN
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.1f * 120);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+        }
 
-        // WHEN
-        event = QT_PREPEND_NAMESPACE(QWheelEvent)(QPointF(500.0, 500.0),
-                                                  QPointF(), QPoint(), QPoint(),
-                                                  Qt::NoButton,
-                                                  Qt::NoModifier,
-                                                  Qt::NoScrollPhase,
-                                                  false);
-        backendMouseDevice.resetMouseAxisState();
-        backendMouseDevice.updateWheelEvent(&event);
+        {
+            // WHEN
+            auto event = QT_PREPEND_NAMESPACE(QWheelEvent)(QPointF(500.0, 500.0),
+                                                           QPointF(), QPoint(), QPoint(),
+                                                           Qt::NoButton,
+                                                           Qt::NoModifier,
+                                                           Qt::NoScrollPhase,
+                                                           false);
+            backendMouseDevice.resetMouseAxisState();
+            backendMouseDevice.updateWheelEvent(&event);
 
-        // THEN
-        QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
-        QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+            // THEN
+            QCOMPARE(backendMouseDevice.mouseState().wXAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.mouseState().wYAxis, 0.0f);
+            QCOMPARE(backendMouseDevice.sensitivity(), 0.1f);
+        }
     }
 #endif
 
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index f66e27793..a6f47042d 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -383,47 +383,55 @@ private Q_SLOTS:
         // THEN
         QVERIFY(pickBVJob.currentPicker().isNull());
 
-        // WHEN
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(!earlyReturn);
-        QVERIFY(!pickBVJob.currentPicker().isNull());
-        Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->data<Qt3DRender::Render::ObjectPicker, Qt3DRender::Render::ObjectPickerManager>(pickBVJob.currentPicker());
-        QVERIFY(backendPicker != nullptr);
-        QCOMPARE(backendPicker->peerId(), picker1->id());
+            // THEN
+            QVERIFY(!earlyReturn);
+            QVERIFY(!pickBVJob.currentPicker().isNull());
+            Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->data<Qt3DRender::Render::ObjectPicker, Qt3DRender::Render::ObjectPickerManager>(pickBVJob.currentPicker());
+            QVERIFY(backendPicker != nullptr);
+            QCOMPARE(backendPicker->peerId(), picker1->id());
+        }
 
-        // WHEN
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207., 303.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207., 303.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(!earlyReturn);
-        QVERIFY(pickBVJob.currentPicker().isNull());
+            // THEN
+            QVERIFY(!earlyReturn);
+            QVERIFY(pickBVJob.currentPicker().isNull());
+        }
 
-        // WHEN
-        event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(390., 300.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(390., 300.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(!earlyReturn);
-        QVERIFY(!pickBVJob.currentPicker().isNull());
-        backendPicker = test->nodeManagers()->data<Qt3DRender::Render::ObjectPicker, Qt3DRender::Render::ObjectPickerManager>(pickBVJob.currentPicker());
-        QVERIFY(backendPicker != nullptr);
-        QCOMPARE(backendPicker->peerId(), picker2->id());
+            // THEN
+            QVERIFY(!earlyReturn);
+            QVERIFY(!pickBVJob.currentPicker().isNull());
+            auto backendPicker = test->nodeManagers()->data<Qt3DRender::Render::ObjectPicker, Qt3DRender::Render::ObjectPickerManager>(pickBVJob.currentPicker());
+            QVERIFY(backendPicker != nullptr);
+            QCOMPARE(backendPicker->peerId(), picker2->id());
+        }
 
-        // WHEN
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(390., 300.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(390., 300.), Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(!earlyReturn);
-        QVERIFY(pickBVJob.currentPicker().isNull());
+            // THEN
+            QVERIFY(!earlyReturn);
+            QVERIFY(pickBVJob.currentPicker().isNull());
+        }
     }
 
     void checkEarlyReturnWhenNoMouseEvents_data()
@@ -626,27 +634,31 @@ private Q_SLOTS:
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
         QCOMPARE(test->renderSettings()->faceOrientationPickingMode(), faceOrientationPickingMode);
 
-        // WHEN
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(!pickBVJob.currentPicker().isNull());
-        QVERIFY(!earlyReturn);
+            // THEN
+            QVERIFY(!pickBVJob.currentPicker().isNull());
+            QVERIFY(!earlyReturn);
+        }
 
-        // WHEN
-        event = QMouseEvent(QMouseEvent::MouseMove, QPointF(207., 303.),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseMove, QPointF(207., 303.),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(earlyReturn);
+            // THEN
+            QVERIFY(earlyReturn);
+        }
     }
 
     void checkNoEarlyReturnWhenMoveEventsAndDragEnabledPickers_data()
@@ -685,27 +697,31 @@ private Q_SLOTS:
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
         QCOMPARE(test->renderSettings()->faceOrientationPickingMode(), faceOrientationPickingMode);
 
-        // WHEN
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207., 303.),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(!pickBVJob.currentPicker().isNull());
-        QVERIFY(!earlyReturn);
+            // THEN
+            QVERIFY(!pickBVJob.currentPicker().isNull());
+            QVERIFY(!earlyReturn);
+        }
 
-        // WHEN
-        event = QMouseEvent(QMouseEvent::MouseMove, QPointF(207., 303.),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
+        {
+            // WHEN
+            auto event = QMouseEvent(QMouseEvent::MouseMove, QPointF(207., 303.),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
 
-        // THEN
-        QVERIFY(!earlyReturn);
+            // THEN
+            QVERIFY(!earlyReturn);
+        }
     }
 
     void checkEarlyReturnWhenNoProperFrameGraph_data()
@@ -822,75 +838,83 @@ private Q_SLOTS:
         QVERIFY(mouseButtonReleasedSpy.isValid());
         QVERIFY(mouseClickedSpy.isValid());
 
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Pressed
-        QVERIFY(!earlyReturn);
-        QVERIFY(backendPicker1->isPressed());
-        QVERIFY(picker1->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
-        QCOMPARE(mouseClickedSpy.count(), 0);
+            // THEN -> Pressed
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker1->isPressed());
+            QVERIFY(picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+            QCOMPARE(mouseClickedSpy.count(), 0);
+        }
 
-        // WHEN -> Move on same object
-        event = QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0, 303.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            // WHEN -> Move on same object
+            auto event = QMouseEvent(QMouseEvent::MouseMove, QPointF(207.0, 303.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Moved
-        QVERIFY(!earlyReturn);
-        QVERIFY(backendPicker1->isPressed());
-        QVERIFY(picker1->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
-        QCOMPARE(mouseClickedSpy.count(), 0);
+            // THEN -> Moved
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker1->isPressed());
+            QVERIFY(picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+            QCOMPARE(mouseClickedSpy.count(), 0);
+        }
 
-        // WHEN -> Release on object
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0, 303.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            // WHEN -> Release on object
+            auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(207.0, 303.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Released + Clicked
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker1->isPressed());
-        QVERIFY(!picker1->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseButtonReleasedSpy.count(), /*backAndFrontPicking ? 2 :*/ 1);
-        QCOMPARE(mouseClickedSpy.count(), 1);
+            // THEN -> Released + Clicked
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseButtonReleasedSpy.count(), /*backAndFrontPicking ? 2 :*/ 1);
+            QCOMPARE(mouseClickedSpy.count(), 1);
+        }
 
         mouseButtonPressedSpy.clear();
         mouseMovedSpy.clear();
         mouseButtonReleasedSpy.clear();
         mouseClickedSpy.clear();
 
-        // WHEN -> Release outside of object
-        event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0, 0.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            // WHEN -> Release outside of object
+            auto event1 = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
+                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event1);
+            auto event2 = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0.0, 0.0),
+                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event2);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Released
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker1->isPressed());
-        QVERIFY(!picker1->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+            // THEN -> Released
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+        }
     }
 
     void checkDispatchReleaseEventOnLastPickerWhenMovingOutOfViewport()
@@ -942,52 +966,58 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
-
-        // THEN -> Pressed
-        QVERIFY(!earlyReturn);
-        QVERIFY(backendPicker1->isPressed());
-        QVERIFY(picker1->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        {
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(207.0, 303.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // WHEN -> Releasing out of the viewport
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0, 10000.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+            // THEN -> Pressed
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker1->isPressed());
+            QVERIFY(picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        }
 
-        // THEN -> Should have received released event
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker1->isPressed());
-        QVERIFY(!picker1->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+        {
+            // WHEN -> Releasing out of the viewport
+            auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0, 10000.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
+            // THEN -> Should have received released event
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+        }
 
-        // WHEN -> Releasing out of the viewport
         mouseButtonPressedSpy.clear();
         mouseMovedSpy.clear();
         mouseButtonReleasedSpy.clear();
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0, 10000.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Should have received nothing
-        QVERIFY(!backendPicker1->isPressed());
-        QVERIFY(!picker1->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), 0);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        {
+            // WHEN -> Releasing out of the viewport
+            auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(10000.0, 10000.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+            // THEN -> Should have received nothing
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), 0);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+        }
     }
 
     void checkDispatchHoverEvent_data()
@@ -1046,52 +1076,58 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        auto event = QMouseEvent(QMouseEvent::HoverMove, QPointF(207.0, 303.0),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event = QMouseEvent(QMouseEvent::HoverMove, QPointF(207.0, 303.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Entered
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker1->isPressed());
-        QVERIFY(!picker1->isPressed());
-        QCOMPARE(mouseEntered.count(), 1);
-        QCOMPARE(mouseExited.count(), 0);
+            // THEN -> Entered
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseEntered.count(), 1);
+            QCOMPARE(mouseExited.count(), 0);
+        }
 
-        // WHEN -> HoverMove Out
-        event = QMouseEvent(QEvent::HoverMove, QPointF(20.0, 40.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            // WHEN -> HoverMove Out
+            auto event = QMouseEvent(QEvent::HoverMove, QPointF(20.0, 40.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN - Exited
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker1->isPressed());
-        QVERIFY(!picker1->isPressed());
-        QCOMPARE(mouseEntered.count(), 1);
-        QCOMPARE(mouseExited.count(), 1);
+            // THEN - Exited
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseEntered.count(), 1);
+            QCOMPARE(mouseExited.count(), 1);
+        }
 
         mouseEntered.clear();
         mouseExited.clear();
 
         // WHEN -> HoverMove In + Pressed other
-        event = QMouseEvent(QEvent::HoverMove, QPointF(207.0, 303.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        event = QMouseEvent(QEvent::MouseButtonPress, QPointF(0.0, 0.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event1 = QMouseEvent(QEvent::HoverMove, QPointF(207.0, 303.0),
+                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event1);
+            auto event2 = QMouseEvent(QEvent::MouseButtonPress, QPointF(0.0, 0.0),
+                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event2);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN - Entered, Exited
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker1->isPressed());
-        QVERIFY(!picker1->isPressed());
-        QCOMPARE(mouseEntered.count(), 1);
-        QCOMPARE(mouseExited.count(), 1);
+            // THEN - Entered, Exited
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker1->isPressed());
+            QVERIFY(!picker1->isPressed());
+            QCOMPARE(mouseEntered.count(), 1);
+            QCOMPARE(mouseExited.count(), 1);
+        }
     }
 
     void shouldDispatchMouseEventFromChildren_data()
@@ -1156,77 +1192,87 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0, 300.0),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400.0, 300.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Pressed
-        QVERIFY(!earlyReturn);
-        QVERIFY(backendPicker->isPressed());
-        QVERIFY(picker->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
-        QCOMPARE(mouseClickedSpy.count(), 0);
+            // THEN -> Pressed
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker->isPressed());
+            QVERIFY(picker->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+            QCOMPARE(mouseClickedSpy.count(), 0);
+        }
 
-        // WHEN -> Move on same object
         mouseButtonPressedSpy.clear();
-        event = QMouseEvent(QMouseEvent::MouseMove, QPointF(400.0, 300.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Moved
-        QVERIFY(!earlyReturn);
-        QVERIFY(backendPicker->isPressed());
-        QVERIFY(picker->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), 0);
-        QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
-        QCOMPARE(mouseClickedSpy.count(), 0);
+        {
+            // WHEN -> Move on same object
+            auto event = QMouseEvent(QMouseEvent::MouseMove, QPointF(400.0, 300.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+            // THEN -> Moved
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker->isPressed());
+            QVERIFY(picker->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), 0);
+            QCOMPARE(mouseMovedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+            QCOMPARE(mouseClickedSpy.count(), 0);
+        }
 
-        // WHEN -> Release on object
         mouseMovedSpy.clear();
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(400.0, 300.0),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Released + Clicked
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker->isPressed());
-        QVERIFY(!picker->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), 0);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
-        QCOMPARE(mouseClickedSpy.count(), 1);
+        // WHEN -> Release on object
+        {
+            auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(400.0, 300.0),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+            // THEN -> Released + Clicked
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker->isPressed());
+            QVERIFY(!picker->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), 0);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+            QCOMPARE(mouseClickedSpy.count(), 1);
+        }
 
         // WHEN -> Release outside of object
         mouseButtonPressedSpy.clear();
         mouseMovedSpy.clear();
         mouseButtonReleasedSpy.clear();
 
-        event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400., 300.),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0., 0.),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event1 = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(400., 300.),
+                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event1);
+            auto event2 = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(0., 0.),
+                                      Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event2);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Released
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker->isPressed());
-        QVERIFY(!picker->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 1);
-        QCOMPARE(mouseClickedSpy.count(), 1);
+            // THEN -> Released
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker->isPressed());
+            QVERIFY(!picker->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 1);
+            QCOMPARE(mouseClickedSpy.count(), 1);
+        }
     }
 
     void checkPickerGrabbing_data()
@@ -1320,50 +1366,54 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320., 303.),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
-
-        // THEN -> Pressed
-        QVERIFY(!earlyReturn);
-        QVERIFY(backendPicker1->isPressed());
-        QVERIFY(picker1->isPressed());
-
-        QCOMPARE(mouseButtonPressedSpy1.count(), backAndFrontPicking ? 2 : 1);
-        QCOMPARE(mouseMovedSpy1.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
-        QCOMPARE(mouseClickedSpy1.count(), 0);
-        QCOMPARE(mouseEntered1.count(), 0);
-        QCOMPARE(mouseExited1.count(), 0);
-
-        // WHEN -> Move on next object, show stay on previous picker unless all picks are requested
-        event = QMouseEvent(QMouseEvent::MouseMove, QPointF(280., 303.),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320., 303.),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Moved over the second picker, is the first one still pressed
-        QVERIFY(!earlyReturn);
-        if (pickResultMode != Qt3DRender::QPickingSettings::AllPicks) {
+            // THEN -> Pressed
+            QVERIFY(!earlyReturn);
             QVERIFY(backendPicker1->isPressed());
             QVERIFY(picker1->isPressed());
-            QCOMPARE(mouseButtonPressedSpy1.count(), 1);
-            QCOMPARE(mouseMovedSpy1.count(), 1);
+
+            QCOMPARE(mouseButtonPressedSpy1.count(), backAndFrontPicking ? 2 : 1);
+            QCOMPARE(mouseMovedSpy1.count(), 0);
             QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
             QCOMPARE(mouseClickedSpy1.count(), 0);
             QCOMPARE(mouseEntered1.count(), 0);
             QCOMPARE(mouseExited1.count(), 0);
-        } else {
-            QVERIFY(!picker2->isPressed());
-            QCOMPARE(mouseButtonPressedSpy2.count(), 0);
-            QCOMPARE(mouseMovedSpy2.count(), backAndFrontPicking ? 2 : 1);
-            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
-            QCOMPARE(mouseClickedSpy2.count(), 0);
-            QCOMPARE(mouseEntered2.count(), 1);
-            QCOMPARE(mouseExited2.count(), 0);
+        }
+
+        {
+            // WHEN -> Move on next object, show stay on previous picker unless all picks are requested
+            auto event = QMouseEvent(QMouseEvent::MouseMove, QPointF(280., 303.),
+                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+            // THEN -> Moved over the second picker, is the first one still pressed
+            QVERIFY(!earlyReturn);
+            if (pickResultMode != Qt3DRender::QPickingSettings::AllPicks) {
+                QVERIFY(backendPicker1->isPressed());
+                QVERIFY(picker1->isPressed());
+                QCOMPARE(mouseButtonPressedSpy1.count(), 1);
+                QCOMPARE(mouseMovedSpy1.count(), 1);
+                QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+                QCOMPARE(mouseClickedSpy1.count(), 0);
+                QCOMPARE(mouseEntered1.count(), 0);
+                QCOMPARE(mouseExited1.count(), 0);
+            } else {
+                QVERIFY(!picker2->isPressed());
+                QCOMPARE(mouseButtonPressedSpy2.count(), 0);
+                QCOMPARE(mouseMovedSpy2.count(), backAndFrontPicking ? 2 : 1);
+                QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+                QCOMPARE(mouseClickedSpy2.count(), 0);
+                QCOMPARE(mouseEntered2.count(), 1);
+                QCOMPARE(mouseExited2.count(), 0);
+            }
         }
     }
 
@@ -1485,43 +1535,47 @@ private Q_SLOTS:
         Qt3DRender::Render::PickBoundingVolumeJob pickBVJob;
         initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
-        auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(280., 300.),
-                                 Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        bool earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(280., 300.),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Pressed
-        QVERIFY(!earlyReturn);
-        QVERIFY(backendPicker->isPressed());
-        QVERIFY(picker->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
-        QCOMPARE(mouseClickedSpy.count(), 0);
-        QCOMPARE(mouseEntered.count(), 0);
-        QCOMPARE(mouseExited.count(), 0);
+            // THEN -> Pressed
+            QVERIFY(!earlyReturn);
+            QVERIFY(backendPicker->isPressed());
+            QVERIFY(picker->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+            QCOMPARE(mouseClickedSpy.count(), 0);
+            QCOMPARE(mouseEntered.count(), 0);
+            QCOMPARE(mouseExited.count(), 0);
+        }
 
         // WHEN reset -> Presset on object in vp2
         backendPicker->cleanup();
         backendPicker->setEnabled(true);
 
-        event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320., 300.),
-                            Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-        pickBVJob.processMouseEvent(nullptr, &event);
-        earlyReturn = !pickBVJob.runHelper();
-        Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+        {
+            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(320., 300.),
+                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+            pickBVJob.processMouseEvent(nullptr, &event);
+            bool earlyReturn = !pickBVJob.runHelper();
+            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
 
-        // THEN -> Nothing happened
-        QVERIFY(!earlyReturn);
-        QVERIFY(!backendPicker->isPressed());
-        QVERIFY(picker->isPressed());
-        QCOMPARE(mouseButtonPressedSpy.count(), 1);
-        QCOMPARE(mouseMovedSpy.count(), 0);
-        QCOMPARE(mouseButtonReleasedSpy.count(), 0);
-        QCOMPARE(mouseClickedSpy.count(), 0);
-        QCOMPARE(mouseEntered.count(), 0);
-        QCOMPARE(mouseExited.count(), 0);
+            // THEN -> Nothing happened
+            QVERIFY(!earlyReturn);
+            QVERIFY(!backendPicker->isPressed());
+            QVERIFY(picker->isPressed());
+            QCOMPARE(mouseButtonPressedSpy.count(), 1);
+            QCOMPARE(mouseMovedSpy.count(), 0);
+            QCOMPARE(mouseButtonReleasedSpy.count(), 0);
+            QCOMPARE(mouseClickedSpy.count(), 0);
+            QCOMPARE(mouseEntered.count(), 0);
+            QCOMPARE(mouseExited.count(), 0);
+        }
     }
 
     void checkMultipleRayDirections_data()
@@ -1687,55 +1741,59 @@ private Q_SLOTS:
             initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
             // WHEN -> Pressed on object
-            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300., 300.),
-                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-            pickBVJob.processMouseEvent(nullptr, &event);
-            bool earlyReturn = !pickBVJob.runHelper();
-            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
-
-            // THEN -> Select picker with highest priority
-            QVERIFY(!earlyReturn);
-            QVERIFY(backendPicker1->isPressed());
-            QVERIFY(picker1->isPressed());
-            QCOMPARE(mouseButtonPressedSpy1.count(), 1);
-            QCOMPARE(mouseMovedSpy1.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
-            QCOMPARE(mouseClickedSpy1.count(), 0);
-            QCOMPARE(mouseEntered1.count(), 0);
-            QCOMPARE(mouseExited1.count(), 0);
-
-            QVERIFY(!backendPicker2->isPressed());
-            QVERIFY(!picker2->isPressed());
-            QCOMPARE(mouseButtonPressedSpy2.count(), 0);
-            QCOMPARE(mouseMovedSpy2.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
-            QCOMPARE(mouseClickedSpy2.count(), 0);
-            QCOMPARE(mouseEntered2.count(), 0);
-            QCOMPARE(mouseExited2.count(), 0);
-
-            event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300., 300.),
-                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-            pickBVJob.processMouseEvent(nullptr, &event);
-            pickBVJob.runHelper();
-            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
-
-            QVERIFY(!backendPicker1->isPressed());
-            QVERIFY(!picker1->isPressed());
-            QCOMPARE(mouseButtonPressedSpy1.count(), 1);
-            QCOMPARE(mouseMovedSpy1.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy1.count(), 1);
-            QCOMPARE(mouseClickedSpy1.count(), 1);
-            QCOMPARE(mouseEntered1.count(), 0);
-            QCOMPARE(mouseExited1.count(), 0);
+            {
+                auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300., 300.),
+                                         Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+                pickBVJob.processMouseEvent(nullptr, &event);
+                bool earlyReturn = !pickBVJob.runHelper();
+                Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+                // THEN -> Select picker with highest priority
+                QVERIFY(!earlyReturn);
+                QVERIFY(backendPicker1->isPressed());
+                QVERIFY(picker1->isPressed());
+                QCOMPARE(mouseButtonPressedSpy1.count(), 1);
+                QCOMPARE(mouseMovedSpy1.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+                QCOMPARE(mouseClickedSpy1.count(), 0);
+                QCOMPARE(mouseEntered1.count(), 0);
+                QCOMPARE(mouseExited1.count(), 0);
+
+                QVERIFY(!backendPicker2->isPressed());
+                QVERIFY(!picker2->isPressed());
+                QCOMPARE(mouseButtonPressedSpy2.count(), 0);
+                QCOMPARE(mouseMovedSpy2.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+                QCOMPARE(mouseClickedSpy2.count(), 0);
+                QCOMPARE(mouseEntered2.count(), 0);
+                QCOMPARE(mouseExited2.count(), 0);
+            }
 
-            QVERIFY(!backendPicker2->isPressed());
-            QVERIFY(!picker2->isPressed());
-            QCOMPARE(mouseButtonPressedSpy2.count(), 0);
-            QCOMPARE(mouseMovedSpy2.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
-            QCOMPARE(mouseClickedSpy2.count(), 0);
-            QCOMPARE(mouseEntered2.count(), 0);
-            QCOMPARE(mouseExited2.count(), 0);
+            {
+                auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300., 300.),
+                                         Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+                pickBVJob.processMouseEvent(nullptr, &event);
+                pickBVJob.runHelper();
+                Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+                QVERIFY(!backendPicker1->isPressed());
+                QVERIFY(!picker1->isPressed());
+                QCOMPARE(mouseButtonPressedSpy1.count(), 1);
+                QCOMPARE(mouseMovedSpy1.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy1.count(), 1);
+                QCOMPARE(mouseClickedSpy1.count(), 1);
+                QCOMPARE(mouseEntered1.count(), 0);
+                QCOMPARE(mouseExited1.count(), 0);
+
+                QVERIFY(!backendPicker2->isPressed());
+                QVERIFY(!picker2->isPressed());
+                QCOMPARE(mouseButtonPressedSpy2.count(), 0);
+                QCOMPARE(mouseMovedSpy2.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+                QCOMPARE(mouseClickedSpy2.count(), 0);
+                QCOMPARE(mouseEntered2.count(), 0);
+                QCOMPARE(mouseExited2.count(), 0);
+            }
         }
 
         mouseButtonPressedSpy1.clear();
@@ -1751,55 +1809,59 @@ private Q_SLOTS:
             initializePickBoundingVolumeJob(&pickBVJob, test.data());
 
             // WHEN -> Pressed on object
-            auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300., 300.),
-                                     Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-            pickBVJob.processMouseEvent(nullptr, &event);
-            bool earlyReturn = !pickBVJob.runHelper();
-            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
-
-            // THEN -> Select picker with highest priority
-            QVERIFY(!earlyReturn);
-            QVERIFY(!backendPicker1->isPressed());
-            QVERIFY(!picker1->isPressed());
-            QCOMPARE(mouseButtonPressedSpy1.count(), 0);
-            QCOMPARE(mouseMovedSpy1.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
-            QCOMPARE(mouseClickedSpy1.count(), 0);
-            QCOMPARE(mouseEntered1.count(), 0);
-            QCOMPARE(mouseExited1.count(), 0);
-
-            QVERIFY(backendPicker2->isPressed());
-            QVERIFY(picker2->isPressed());
-            QCOMPARE(mouseButtonPressedSpy2.count(), 1);
-            QCOMPARE(mouseMovedSpy2.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
-            QCOMPARE(mouseClickedSpy2.count(), 0);
-            QCOMPARE(mouseEntered2.count(), 0);
-            QCOMPARE(mouseExited2.count(), 0);
-
-            event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300., 300.),
-                                Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
-            pickBVJob.processMouseEvent(nullptr, &event);
-            pickBVJob.runHelper();
-            Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
-
-            QVERIFY(!backendPicker1->isPressed());
-            QVERIFY(!picker1->isPressed());
-            QCOMPARE(mouseButtonPressedSpy1.count(), 0);
-            QCOMPARE(mouseMovedSpy1.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
-            QCOMPARE(mouseClickedSpy1.count(), 0);
-            QCOMPARE(mouseEntered1.count(), 0);
-            QCOMPARE(mouseExited1.count(), 0);
+            {
+                auto event = QMouseEvent(QMouseEvent::MouseButtonPress, QPointF(300., 300.),
+                                         Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+                pickBVJob.processMouseEvent(nullptr, &event);
+                bool earlyReturn = !pickBVJob.runHelper();
+                Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+                // THEN -> Select picker with highest priority
+                QVERIFY(!earlyReturn);
+                QVERIFY(!backendPicker1->isPressed());
+                QVERIFY(!picker1->isPressed());
+                QCOMPARE(mouseButtonPressedSpy1.count(), 0);
+                QCOMPARE(mouseMovedSpy1.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+                QCOMPARE(mouseClickedSpy1.count(), 0);
+                QCOMPARE(mouseEntered1.count(), 0);
+                QCOMPARE(mouseExited1.count(), 0);
+
+                QVERIFY(backendPicker2->isPressed());
+                QVERIFY(picker2->isPressed());
+                QCOMPARE(mouseButtonPressedSpy2.count(), 1);
+                QCOMPARE(mouseMovedSpy2.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy2.count(), 0);
+                QCOMPARE(mouseClickedSpy2.count(), 0);
+                QCOMPARE(mouseEntered2.count(), 0);
+                QCOMPARE(mouseExited2.count(), 0);
+            }
 
-            QVERIFY(!backendPicker2->isPressed());
-            QVERIFY(!picker2->isPressed());
-            QCOMPARE(mouseButtonPressedSpy2.count(), 1);
-            QCOMPARE(mouseMovedSpy2.count(), 0);
-            QCOMPARE(mouseButtonReleasedSpy2.count(), 1);
-            QCOMPARE(mouseClickedSpy2.count(), 1);
-            QCOMPARE(mouseEntered2.count(), 0);
-            QCOMPARE(mouseExited2.count(), 0);
+            {
+                auto event = QMouseEvent(QMouseEvent::MouseButtonRelease, QPointF(300., 300.),
+                                         Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
+                pickBVJob.processMouseEvent(nullptr, &event);
+                pickBVJob.runHelper();
+                Qt3DCore::QAspectJobPrivate::get(&pickBVJob)->postFrame(test->aspectManager());
+
+                QVERIFY(!backendPicker1->isPressed());
+                QVERIFY(!picker1->isPressed());
+                QCOMPARE(mouseButtonPressedSpy1.count(), 0);
+                QCOMPARE(mouseMovedSpy1.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy1.count(), 0);
+                QCOMPARE(mouseClickedSpy1.count(), 0);
+                QCOMPARE(mouseEntered1.count(), 0);
+                QCOMPARE(mouseExited1.count(), 0);
+
+                QVERIFY(!backendPicker2->isPressed());
+                QVERIFY(!picker2->isPressed());
+                QCOMPARE(mouseButtonPressedSpy2.count(), 1);
+                QCOMPARE(mouseMovedSpy2.count(), 0);
+                QCOMPARE(mouseButtonReleasedSpy2.count(), 1);
+                QCOMPARE(mouseClickedSpy2.count(), 1);
+                QCOMPARE(mouseEntered2.count(), 0);
+                QCOMPARE(mouseExited2.count(), 0);
+            }
         }
     }