Update eventForward unit tests

Change-Id: Id0898fde106ac9a4407033867a13e46f7ce4b86e
Reviewed-by: Tomi Korpipää <tomi.korpipaa@qt.io>
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

2 files changed, 207 insertions, 21 deletions

diff --git a/tests/auto/render/eventforward/tst_eventforward.cpp b/tests/auto/render/eventforward/tst_eventforward.cpp
index 5352853a1..de86b8ef3 100644
--- a/tests/auto/render/eventforward/tst_eventforward.cpp
+++ b/tests/auto/render/eventforward/tst_eventforward.cpp
@@ -28,11 +28,15 @@
 
 #include <QtTest/QTest>
 #include <Qt3DRender/qeventforward.h>
-#include <Qt3DRender/private/qeventforward_p.h>
-#include <Qt3DRender/private/eventforward_p.h>
+#include <private/qeventforward_p.h>
+#include <private/eventforward_p.h>
+#include <private/posteventstofrontend_p.h>
+#include <private/qbackendnode_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
 #include "qbackendnodetester.h"
 #include "testrenderer.h"
+#include "testpostmanarbiter.h"
+
 
 class tst_EventForward : public Qt3DCore::QBackendNodeTester
 {
@@ -48,7 +52,6 @@ private Q_SLOTS:
         // THEN
         QCOMPARE(backendEventForward.isEnabled(), false);
         QVERIFY(backendEventForward.peerId().isNull());
-        QCOMPARE(backendEventForward.target(), nullptr);
         QCOMPARE(backendEventForward.coordinateAttribute(), QStringLiteral(""));
         QCOMPARE(backendEventForward.coordinateTransform(), QMatrix4x4());
         QCOMPARE(backendEventForward.forwardMouseEvents(), false);
@@ -66,7 +69,6 @@ private Q_SLOTS:
 
         // WHEN
         backendEventForward.setEnabled(true);
-        backendEventForward.setTarget(obj.data());
         backendEventForward.setCoordinateAttribute(QStringLiteral("default"));
         backendEventForward.setCoordinateTransform(transform);
         backendEventForward.setForwardMouseEvents(true);
@@ -77,7 +79,6 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(backendEventForward.isEnabled(), false);
-        QCOMPARE(backendEventForward.target(), nullptr);
         QCOMPARE(backendEventForward.coordinateAttribute(), QStringLiteral(""));
         QCOMPARE(backendEventForward.coordinateTransform(), QMatrix4x4());
         QCOMPARE(backendEventForward.forwardMouseEvents(), false);
@@ -98,7 +99,6 @@ private Q_SLOTS:
             // THEN
             QCOMPARE(backendEventForward.isEnabled(), true);
             QCOMPARE(backendEventForward.peerId(), eventForward.id());
-            QCOMPARE(backendEventForward.target(), nullptr);
             QCOMPARE(backendEventForward.coordinateAttribute(), QStringLiteral("default"));
             QCOMPARE(backendEventForward.coordinateTransform(), QMatrix4x4());
             QCOMPARE(backendEventForward.forwardMouseEvents(), true);
@@ -139,18 +139,6 @@ private Q_SLOTS:
         }
         {
              // WHEN
-             QScopedPointer<Qt3DRender::QEventForward> obj(new Qt3DRender::QEventForward());
-             Qt3DRender::QEventForward * newValue = obj.data();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("target");
-             change->setValue(QVariant::fromValue(newValue));
-             backendEventForward.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendEventForward.target(), newValue);
-        }
-        {
-             // WHEN
              const QString newValue = QStringLiteral("position");
              const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
              change->setPropertyName("coordinateAttribute");
@@ -206,7 +194,83 @@ private Q_SLOTS:
             QCOMPARE(backendEventForward.focus(), newValue);
         }
     }
+    void checkEventForwarding()
+    {
+        Qt3DRender::Render::EventForward backendEventForward;
+        TestRenderer renderer;
+        TestArbiter arbiter;
+        backendEventForward.setRenderer(&renderer);
+        Qt3DCore::QBackendNodePrivate::get(&backendEventForward)->setArbiter(&arbiter);
+
+        {
+            // WHEN
+            const QPointF localPos;
+            QMouseEvent event = QMouseEvent(QEvent::MouseButtonPress, localPos,
+                                            Qt::LeftButton, Qt::LeftButton, 0);
+
+            const QVector4D coordinate;
+            backendEventForward.forward(event, coordinate);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QVERIFY(arbiter.events.size() == 1);
+            Qt3DCore::QPropertyUpdatedChangePtr change
+                    = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+            QCOMPARE(change->propertyName(), "events");
+
+            Qt3DRender::PostEventsToFrontendPtr postedEvents
+                    = change->value().value<Qt3DRender::PostEventsToFrontendPtr>();
+            QVERIFY(postedEvents->events().size() == 1);
+
+            QEvent *receivedEvent = postedEvents->events().first();
+            QCOMPARE(receivedEvent->type(), QEvent::MouseButtonPress);
+
+            QMouseEvent *me = static_cast<QMouseEvent*>(receivedEvent);
+            QCOMPARE(me->localPos(), localPos);
+            QCOMPARE(me->button(), Qt::LeftButton);
+            QCOMPARE(me->buttons(), Qt::LeftButton);
+            QCOMPARE(me->modifiers(), 0);
+
+            arbiter.events.clear();
+        }
+
+        {
+            // WHEN
+            QKeyEvent event1 = QKeyEvent(QEvent::KeyPress, 48, 0);
+            QKeyEvent event2 = QKeyEvent(QEvent::KeyRelease, 48, 0);
+            QList<QKeyEvent> eventList;
+            eventList.push_back(event1);
+            eventList.push_back(event2);
 
+            backendEventForward.forward(eventList);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QVERIFY(arbiter.events.size() == 1);
+            Qt3DCore::QPropertyUpdatedChangePtr change
+                    = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
+            QCOMPARE(change->propertyName(), "events");
+
+            Qt3DRender::PostEventsToFrontendPtr postedEvents
+                    = change->value().value<Qt3DRender::PostEventsToFrontendPtr>();
+            QVERIFY(postedEvents->events().size() == 2);
+
+            QEvent *receivedEvent1 = postedEvents->events().first();
+            QCOMPARE(receivedEvent1->type(), QEvent::KeyPress);
+
+            QEvent *receivedEvent2 = postedEvents->events().at(1);
+            QCOMPARE(receivedEvent2->type(), QEvent::KeyRelease);
+
+            QKeyEvent *ke1 = static_cast<QKeyEvent*>(receivedEvent1);
+            QKeyEvent *ke2 = static_cast<QKeyEvent*>(receivedEvent2);
+            QCOMPARE(ke1->key(), 48);
+            QCOMPARE(ke1->modifiers(), 0);
+            QCOMPARE(ke2->key(), 48);
+            QCOMPARE(ke2->modifiers(), 0);
+
+            arbiter.events.clear();
+        }
+    }
 };
 
 QTEST_MAIN(tst_EventForward)
diff --git a/tests/auto/render/qeventforward/tst_qeventforward.cpp b/tests/auto/render/qeventforward/tst_qeventforward.cpp
index aa525d4a2..eeca5b3ea 100644
--- a/tests/auto/render/qeventforward/tst_qeventforward.cpp
+++ b/tests/auto/render/qeventforward/tst_qeventforward.cpp
@@ -29,14 +29,73 @@
 #include <QtTest/QTest>
 #include <Qt3DRender/qattribute.h>
 #include <Qt3DRender/qeventforward.h>
-#include <Qt3DRender/private/qeventforward_p.h>
+#include <private/qeventforward_p.h>
 #include <QObject>
 #include <QSignalSpy>
 #include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
+#include <private/qnodecreatedchangegenerator_p.h>
+#include <private/posteventstofrontend_p.h>
 #include <Qt3DCore/qnodecreatedchange.h>
 #include "testpostmanarbiter.h"
 
+
+class EventReceiver : public QObject
+{
+public:
+    EventReceiver()
+        : QObject()
+    {
+
+    }
+
+    ~EventReceiver()
+    {
+
+    }
+
+    int eventCount()
+    {
+        return m_events.size();
+    }
+
+    QEvent *eventAt(int index) const
+    {
+        return m_events.at(index);
+    }
+    bool event(QEvent *event) Q_DECL_OVERRIDE
+    {
+        m_events.push_back(event);
+        return true;
+    }
+
+    void clearEvents()
+    {
+        m_events.clear();
+    }
+
+private:
+    QVector<QEvent *> m_events;
+};
+
+class TestEventForward : public Qt3DRender::QEventForward
+{
+    Q_OBJECT
+public:
+    TestEventForward(Qt3DCore::QNode *parent = nullptr)
+        : Qt3DRender::QEventForward(parent)
+    {}
+
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) Q_DECL_FINAL
+    {
+        Qt3DRender::QEventForward::sceneChangeEvent(change);
+    }
+
+private:
+    friend class tst_QEventForward;
+
+};
+
+
 class tst_QEventForward : public QObject
 {
     Q_OBJECT
@@ -452,9 +511,72 @@ private Q_SLOTS:
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
         }
-
     }
 
+    void checkReceiveEvents()
+    {
+        EventReceiver receiver;
+        TestEventForward eventForward;
+        eventForward.setTarget(&receiver);
+        eventForward.setForwardKeyboardEvents(true);
+        eventForward.setForwardMouseEvents(true);
+
+        {
+            // WHEN
+            const QPointF local = QPointF();
+            QMouseEvent* mouseEvent
+                    = new QMouseEvent(QEvent::MouseButtonPress, local, local, local,
+                            Qt::LeftButton,0,0, Qt::MouseEventSynthesizedByApplication);
+            Qt3DRender::PostEventsToFrontendPtr events
+                    = Qt3DRender::PostEventsToFrontendPtr::create(mouseEvent);
+
+            auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
+            e->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            e->setPropertyName("events");
+            e->setValue(QVariant::fromValue(events));
+
+            eventForward.sceneChangeEvent(e);
+
+            // THEN
+            QVERIFY(receiver.eventCount() == 1);
+            QEvent *event = receiver.eventAt(0);
+            QCOMPARE(event->type(), QEvent::MouseButtonPress);
+
+            QMouseEvent *me = static_cast<QMouseEvent *>(receiver.eventAt(0));
+            QCOMPARE(me->localPos(), local);
+            QCOMPARE(me->button(), Qt::LeftButton);
+
+            receiver.clearEvents();
+        }
+
+        {
+            // WHEN
+            QKeyEvent *event1 = new QKeyEvent(QEvent::KeyPress, 48, 0);
+            QKeyEvent *event2 = new QKeyEvent(QEvent::KeyRelease, 48, 0);
+            QVector<QEvent *> eventList;
+            eventList.push_back(event1);
+            eventList.push_back(event2);
+            Qt3DRender::PostEventsToFrontendPtr events
+                    = Qt3DRender::PostEventsToFrontendPtr::create(eventList);
+
+            auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
+            e->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            e->setPropertyName("events");
+            e->setValue(QVariant::fromValue(events));
+
+            eventForward.sceneChangeEvent(e);
+
+            // THEN
+            QVERIFY(receiver.eventCount() == 2);
+            QEvent *event = receiver.eventAt(0);
+            QCOMPARE(event->type(), QEvent::KeyPress);
+            QCOMPARE(static_cast<QKeyEvent *>(event)->key(), 48);
+
+            event = receiver.eventAt(1);
+            QCOMPARE(event->type(), QEvent::KeyRelease);
+            QCOMPARE(static_cast<QKeyEvent *>(event)->key(), 48);
+        }
+    }
 };
 
 QTEST_MAIN(tst_QEventForward)