Extend test to cover preparePropertyChanges helper

Change-Id: Ic89792a47ea6ec85924d9d7ba352d98bf86f0469
Reviewed-by: Mike Krus <mike.krus@kdab.com>

1 files changed, 248 insertions, 0 deletions

diff --git a/tests/auto/animation/animationutils/tst_animationutils.cpp b/tests/auto/animation/animationutils/tst_animationutils.cpp
index 419bff1fa..622990829 100644
--- a/tests/auto/animation/animationutils/tst_animationutils.cpp
+++ b/tests/auto/animation/animationutils/tst_animationutils.cpp
@@ -33,6 +33,12 @@
 #include <Qt3DAnimation/private/channelmapping_p.h>
 #include <Qt3DAnimation/private/handler_p.h>
 #include <Qt3DAnimation/private/managers_p.h>
+#include <Qt3DCore/qpropertyupdatedchange.h>
+#include <QtGui/qvector2d.h>
+#include <QtGui/qvector3d.h>
+#include <QtGui/qvector4d.h>
+#include <QtGui/qquaternion.h>
+
 #include <qbackendnodetester.h>
 #include <testpostmanarbiter.h>
 
@@ -43,6 +49,7 @@ Q_DECLARE_METATYPE(QVector<ChannelMapping *>)
 Q_DECLARE_METATYPE(ChannelMapper *)
 Q_DECLARE_METATYPE(AnimationClipLoader *)
 Q_DECLARE_METATYPE(QVector<MappingData>)
+Q_DECLARE_METATYPE(QVector<Qt3DCore::QPropertyUpdatedChangePtr>)
 
 class tst_AnimationUtils : public Qt3DCore::QBackendNodeTester
 {
@@ -324,6 +331,247 @@ private Q_SLOTS:
         QCOMPARE(actualCurrentLoop, expectedCurrentLoop);
         QCOMPARE(actualLocalTime, expectedLocalTime);
     }
+
+    void checkPreparePropertyChanges_data()
+    {
+        QTest::addColumn<Qt3DCore::QNodeId>("animatorId");
+        QTest::addColumn<QVector<MappingData>>("mappingData");
+        QTest::addColumn<QVector<float>>("channelResults");
+        QTest::addColumn<bool>("finalFrame");
+        QTest::addColumn<QVector<Qt3DCore::QPropertyUpdatedChangePtr>>("expectedChanges");
+
+        Qt3DCore::QNodeId animatorId;
+        QVector<MappingData> mappingData;
+        QVector<float> channelResults;
+        bool finalFrame;
+        QVector<Qt3DCore::QPropertyUpdatedChangePtr> expectedChanges;
+
+        // Single property, vec3
+        {
+            animatorId = Qt3DCore::QNodeId::createId();
+            MappingData mapping;
+            mapping.targetId = Qt3DCore::QNodeId::createId();
+            mapping.propertyName = "translation";
+            mapping.type = static_cast<int>(QVariant::Vector3D);
+            mapping.channelIndices = QVector<int>() << 0 << 1 << 2;
+            mappingData.push_back(mapping);
+            channelResults = QVector<float>() << 1.0f << 2.0f << 3.0f;
+            finalFrame = false;
+
+            auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(mapping.targetId);
+            change->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            change->setPropertyName(mapping.propertyName);
+            change->setValue(QVariant::fromValue(QVector3D(1.0f, 2.0f, 3.0f)));
+            expectedChanges.push_back(change);
+
+            QTest::newRow("vec3 translation, final = false")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            finalFrame = true;
+            auto animatorChange = Qt3DCore::QPropertyUpdatedChangePtr::create(animatorId);
+            animatorChange->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            animatorChange->setPropertyName("running");
+            animatorChange->setValue(false);
+            expectedChanges.push_back(animatorChange);
+
+            QTest::newRow("vec3 translation, final = true")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            mappingData.clear();
+            channelResults.clear();
+            expectedChanges.clear();
+        }
+
+        // Multiple properties, all vec3
+        {
+            animatorId = Qt3DCore::QNodeId::createId();
+            MappingData translationMapping;
+            translationMapping.targetId = Qt3DCore::QNodeId::createId();
+            translationMapping.propertyName = "translation";
+            translationMapping.type = static_cast<int>(QVariant::Vector3D);
+            translationMapping.channelIndices = QVector<int>() << 0 << 1 << 2;
+            mappingData.push_back(translationMapping);
+
+            MappingData scaleMapping;
+            scaleMapping.targetId = Qt3DCore::QNodeId::createId();
+            scaleMapping.propertyName = "scale";
+            scaleMapping.type = static_cast<int>(QVariant::Vector3D);
+            scaleMapping.channelIndices = QVector<int>() << 3 << 4 << 5;
+            mappingData.push_back(scaleMapping);
+
+            channelResults = QVector<float>() << 1.0f << 2.0f << 3.0f
+                                              << 4.0f << 5.0f << 6.0f;
+            finalFrame = false;
+
+            auto translationChange = Qt3DCore::QPropertyUpdatedChangePtr::create(translationMapping.targetId);
+            translationChange->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            translationChange->setPropertyName(translationMapping.propertyName);
+            translationChange->setValue(QVariant::fromValue(QVector3D(1.0f, 2.0f, 3.0f)));
+            expectedChanges.push_back(translationChange);
+
+            auto scaleChange = Qt3DCore::QPropertyUpdatedChangePtr::create(scaleMapping.targetId);
+            scaleChange->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            scaleChange->setPropertyName(scaleMapping.propertyName);
+            scaleChange->setValue(QVariant::fromValue(QVector3D(4.0f, 5.0f, 6.0f)));
+            expectedChanges.push_back(scaleChange);
+
+            QTest::newRow("vec3 translation, vec3 scale, final = false")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            finalFrame = true;
+            auto animatorChange = Qt3DCore::QPropertyUpdatedChangePtr::create(animatorId);
+            animatorChange->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            animatorChange->setPropertyName("running");
+            animatorChange->setValue(false);
+            expectedChanges.push_back(animatorChange);
+
+            QTest::newRow("vec3 translation, vec3 scale, final = true")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            mappingData.clear();
+            channelResults.clear();
+            expectedChanges.clear();
+        }
+
+        // Single property, double
+        {
+            animatorId = Qt3DCore::QNodeId::createId();
+            MappingData mapping;
+            mapping.targetId = Qt3DCore::QNodeId::createId();
+            mapping.propertyName = "mass";
+            mapping.type = static_cast<int>(QVariant::Double);
+            mapping.channelIndices = QVector<int>() << 0;
+            mappingData.push_back(mapping);
+            channelResults = QVector<float>() << 3.5f;
+            finalFrame = false;
+
+            auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(mapping.targetId);
+            change->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            change->setPropertyName(mapping.propertyName);
+            change->setValue(QVariant::fromValue(3.5f));
+            expectedChanges.push_back(change);
+
+            QTest::newRow("double mass")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            mappingData.clear();
+            channelResults.clear();
+            expectedChanges.clear();
+        }
+
+        // Single property, vec2
+        {
+            animatorId = Qt3DCore::QNodeId::createId();
+            MappingData mapping;
+            mapping.targetId = Qt3DCore::QNodeId::createId();
+            mapping.propertyName = "pos";
+            mapping.type = static_cast<int>(QVariant::Vector2D);
+            mapping.channelIndices = QVector<int>() << 0 << 1;
+            mappingData.push_back(mapping);
+            channelResults = QVector<float>() << 2.0f << 1.0f;
+            finalFrame = false;
+
+            auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(mapping.targetId);
+            change->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            change->setPropertyName(mapping.propertyName);
+            change->setValue(QVariant::fromValue(QVector2D(2.0f, 1.0f)));
+            expectedChanges.push_back(change);
+
+            QTest::newRow("vec2 pos")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            mappingData.clear();
+            channelResults.clear();
+            expectedChanges.clear();
+        }
+
+        // Single property, vec4
+        {
+            animatorId = Qt3DCore::QNodeId::createId();
+            MappingData mapping;
+            mapping.targetId = Qt3DCore::QNodeId::createId();
+            mapping.propertyName = "foo";
+            mapping.type = static_cast<int>(QVariant::Vector2D);
+            mapping.channelIndices = QVector<int>() << 0 << 1 << 2 << 3;
+            mappingData.push_back(mapping);
+            channelResults = QVector<float>() << 4.0f << 3.0f << 2.0f << 1.0f;
+            finalFrame = false;
+
+            auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(mapping.targetId);
+            change->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            change->setPropertyName(mapping.propertyName);
+            change->setValue(QVariant::fromValue(QVector4D(4.0f, 3.0f, 2.0f, 1.0f)));
+            expectedChanges.push_back(change);
+
+            QTest::newRow("vec4 foo")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            mappingData.clear();
+            channelResults.clear();
+            expectedChanges.clear();
+        }
+
+        // Single property, quaternion
+        {
+            animatorId = Qt3DCore::QNodeId::createId();
+            MappingData mapping;
+            mapping.targetId = Qt3DCore::QNodeId::createId();
+            mapping.propertyName = "rotation";
+            mapping.type = static_cast<int>(QVariant::Quaternion);
+            mapping.channelIndices = QVector<int>() << 0 << 1 << 2 << 3;
+            mappingData.push_back(mapping);
+            channelResults = QVector<float>() << 1.0f << 0.0f << 0.0f << 1.0f;
+            finalFrame = false;
+
+            auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(mapping.targetId);
+            change->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
+            change->setPropertyName(mapping.propertyName);
+            change->setValue(QVariant::fromValue(QQuaternion(1.0f, 0.0f, 0.0f, 1.0f)));
+            expectedChanges.push_back(change);
+
+            QTest::newRow("quaternion rotation")
+                    << animatorId << mappingData << channelResults << finalFrame
+                    << expectedChanges;
+
+            mappingData.clear();
+            channelResults.clear();
+            expectedChanges.clear();
+        }
+    }
+
+    void checkPreparePropertyChanges()
+    {
+        // GIVEN
+        QFETCH(Qt3DCore::QNodeId, animatorId);
+        QFETCH(QVector<MappingData>, mappingData);
+        QFETCH(QVector<float>, channelResults);
+        QFETCH(bool, finalFrame);
+        QFETCH(QVector<Qt3DCore::QPropertyUpdatedChangePtr>, expectedChanges);
+
+        // WHEN
+        QVector<Qt3DCore::QSceneChangePtr> actualChanges
+                = preparePropertyChanges(animatorId, mappingData, channelResults, finalFrame);
+
+        // THEN
+        QCOMPARE(actualChanges.size(), expectedChanges.size());
+        for (int i = 0; i < actualChanges.size(); ++i) {
+            auto expectedChange = expectedChanges[i];
+            auto actualChange
+                    = qSharedPointerCast<Qt3DCore::QPropertyUpdatedChange>(expectedChanges[i]);
+
+            QCOMPARE(actualChange->subjectId(), expectedChange->subjectId());
+            QCOMPARE(actualChange->deliveryFlags(), expectedChange->deliveryFlags());
+            QCOMPARE(actualChange->propertyName(), expectedChange->propertyName());
+            QCOMPARE(actualChange->value(), expectedChange->value());
+        }
+    }
 };
 
 QTEST_MAIN(tst_AnimationUtils)