Merge "Merge remote-tracking branch 'origin/5.14' into 5.15"

37 files changed, 478 insertions, 707 deletions

diff --git a/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp b/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp
index 462c02518..d53fd9c2c 100644
--- a/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp
+++ b/tests/auto/animation/additiveclipblend/tst_additiveclipblend.cpp
@@ -143,7 +143,7 @@ private Q_SLOTS:
         {
             // WHEN
             AdditiveClipBlend backendAdditiveBlend;
-            simulateInitialization(&additiveBlend, &backendAdditiveBlend);
+            simulateInitializationSync(&additiveBlend, &backendAdditiveBlend);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.isEnabled(), true);
@@ -156,7 +156,7 @@ private Q_SLOTS:
             // WHEN
             AdditiveClipBlend backendAdditiveBlend;
             additiveBlend.setEnabled(false);
-            simulateInitialization(&additiveBlend, &backendAdditiveBlend);
+            simulateInitializationSync(&additiveBlend, &backendAdditiveBlend);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.peerId(), additiveBlend.id());
@@ -167,14 +167,14 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QAdditiveClipBlend additiveBlend;
         AdditiveClipBlend backendAdditiveBlend;
+        simulateInitializationSync(&additiveBlend, &backendAdditiveBlend);
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendAdditiveBlend.sceneChangeEvent(change);
+            additiveBlend.setEnabled(newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.isEnabled(), newValue);
@@ -182,32 +182,26 @@ private Q_SLOTS:
         {
             // WHEN
             const float newValue = 0.883f;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("additiveFactor");
-            change->setValue(QVariant::fromValue(newValue));
-            backendAdditiveBlend.sceneChangeEvent(change);
+            additiveBlend.setAdditiveFactor(newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.additiveFactor(), newValue);
         }
         {
             // WHEN
-            const Qt3DAnimation::QAdditiveClipBlend newValue;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("baseClip");
-            change->setValue(QVariant::fromValue(newValue.id()));
-            backendAdditiveBlend.sceneChangeEvent(change);
+            Qt3DAnimation::QAdditiveClipBlend newValue;
+            additiveBlend.setBaseClip(&newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.baseClipId(), newValue.id());
         }
         {
             // WHEN
-            const Qt3DAnimation::QAdditiveClipBlend newValue;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("additiveClip");
-            change->setValue(QVariant::fromValue(newValue.id()));
-            backendAdditiveBlend.sceneChangeEvent(change);
+            Qt3DAnimation::QAdditiveClipBlend newValue;
+            additiveBlend.setAdditiveClip(&newValue);
+            backendAdditiveBlend.syncFromFrontEnd(&additiveBlend, false);
 
             // THEN
             QCOMPARE(backendAdditiveBlend.additiveClipId(), newValue.id());
diff --git a/tests/auto/animation/animationclip/tst_animationclip.cpp b/tests/auto/animation/animationclip/tst_animationclip.cpp
index 15ee60581..a98fbe886 100644
--- a/tests/auto/animation/animationclip/tst_animationclip.cpp
+++ b/tests/auto/animation/animationclip/tst_animationclip.cpp
@@ -55,7 +55,7 @@ private Q_SLOTS:
         clip.setSource(QUrl::fromLocalFile("walk.qlip"));
 
         // WHEN
-        simulateInitialization(&clip, &backendClip);
+        simulateInitializationSync(&clip, &backendClip);
 
         // THEN
         QCOMPARE(backendClip.peerId(), clip.id());
@@ -82,7 +82,7 @@ private Q_SLOTS:
         clip.setSource(QUrl::fromLocalFile("walk.qlip"));
 
         // WHEN
-        simulateInitialization(&clip, &backendClip);
+        simulateInitializationSync(&clip, &backendClip);
         backendClip.setSource(QUrl::fromLocalFile("run.qlip"));
         backendClip.cleanup();
 
@@ -96,27 +96,23 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QAnimationClipLoader clip;
         AnimationClip backendClip;
         Handler handler;
         backendClip.setHandler(&handler);
-        backendClip.setDataType(Qt3DAnimation::Animation::AnimationClip::File);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&clip, &backendClip);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendClip.sceneChangeEvent(updateChange);
+        clip.setEnabled(false);
+        backendClip.syncFromFrontEnd(&clip, false);
 
         // THEN
-        QCOMPARE(backendClip.isEnabled(), true);
+        QCOMPARE(backendClip.isEnabled(), false);
 
         // WHEN
         const QUrl newSource = QUrl::fromLocalFile("fallover.qlip");
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("source");
-        updateChange->setValue(newSource);
-        backendClip.sceneChangeEvent(updateChange);
+        clip.setSource(newSource);
+        backendClip.syncFromFrontEnd(&clip, false);
 
         // THEN
         QCOMPARE(backendClip.source(), newSource);
diff --git a/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp b/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
index c0e1581f9..bb95fe979 100644
--- a/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
+++ b/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
@@ -29,6 +29,7 @@
 #include <QtTest/QTest>
 #include <Qt3DAnimation/private/blendedclipanimator_p.h>
 #include <Qt3DAnimation/qanimationcliploader.h>
+#include <Qt3DAnimation/qadditiveclipblend.h>
 #include <Qt3DAnimation/qblendedclipanimator.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
@@ -114,7 +115,7 @@ private Q_SLOTS:
             Qt3DAnimation::Animation::Handler handler;
             backendBlendedClipAnimator.setHandler(&handler);
 
-            simulateInitialization(&blendedClipAnimator, &backendBlendedClipAnimator);
+            simulateInitializationSync(&blendedClipAnimator, &backendBlendedClipAnimator);
 
             // THEN
             QCOMPARE(backendBlendedClipAnimator.isEnabled(), true);
@@ -131,7 +132,7 @@ private Q_SLOTS:
             backendBlendedClipAnimator.setHandler(&handler);
 
             blendedClipAnimator.setEnabled(false);
-            simulateInitialization(&blendedClipAnimator, &backendBlendedClipAnimator);
+            simulateInitializationSync(&blendedClipAnimator, &backendBlendedClipAnimator);
 
             // THEN
             QCOMPARE(backendBlendedClipAnimator.peerId(), blendedClipAnimator.id());
@@ -142,61 +143,53 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QBlendedClipAnimator blendedClipAnimator;
         Qt3DAnimation::Animation::BlendedClipAnimator backendBlendedClipAnimator;
         Qt3DAnimation::Animation::Handler handler;
         backendBlendedClipAnimator.setHandler(&handler);
+        simulateInitializationSync(&blendedClipAnimator, &backendBlendedClipAnimator);
 
         {
-             // WHEN
-             const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = false;
+            blendedClipAnimator.setEnabled(newValue);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
             QCOMPARE(backendBlendedClipAnimator.isEnabled(), newValue);
         }
         {
-             // WHEN
-             const Qt3DCore::QNodeId newValue = Qt3DCore::QNodeId::createId();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("blendTree");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlendedClipAnimator.blendTreeRootId(), newValue);
+            // WHEN
+            auto blendTree = new Qt3DAnimation::QAdditiveClipBlend();
+            blendedClipAnimator.setBlendTree(blendTree);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
+            QCOMPARE(backendBlendedClipAnimator.blendTreeRootId(), blendTree->id());
         }
         {
-             // WHEN
-             const Qt3DCore::QNodeId newValue = Qt3DCore::QNodeId::createId();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("channelMapper");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlendedClipAnimator.mapperId(), newValue);
+            // WHEN
+            auto channelMapper = new Qt3DAnimation::QChannelMapper();
+            blendedClipAnimator.setChannelMapper(channelMapper);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
+            QCOMPARE(backendBlendedClipAnimator.mapperId(), channelMapper->id());
         }
         {
-             // WHEN
-             const bool newValue = true;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("running");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlendedClipAnimator.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = true;
+            blendedClipAnimator.setRunning(newValue);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
+
+            // THEN
             QCOMPARE(backendBlendedClipAnimator.isRunning(), newValue);
         }
         {
             // WHEN
             const int newValue = 883;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("loops");
-            change->setValue(QVariant::fromValue(newValue));
-            backendBlendedClipAnimator.sceneChangeEvent(change);
+            blendedClipAnimator.setLoopCount(newValue);
+            backendBlendedClipAnimator.syncFromFrontEnd(&blendedClipAnimator, false);
 
             // THEN
             QCOMPARE(backendBlendedClipAnimator.loops(), newValue);
diff --git a/tests/auto/animation/channelmapper/tst_channelmapper.cpp b/tests/auto/animation/channelmapper/tst_channelmapper.cpp
index 446e1a0c5..2dfa07a43 100644
--- a/tests/auto/animation/channelmapper/tst_channelmapper.cpp
+++ b/tests/auto/animation/channelmapper/tst_channelmapper.cpp
@@ -60,7 +60,7 @@ private Q_SLOTS:
         mapper.addMapping(new Qt3DAnimation::QChannelMapping);
 
         // WHEN
-        simulateInitialization(&mapper, &backendMapper);
+        simulateInitializationSync(&mapper, &backendMapper);
 
         // THEN
         QCOMPARE(backendMapper.peerId(), mapper.id());
@@ -90,7 +90,7 @@ private Q_SLOTS:
         mapper.addMapping(new Qt3DAnimation::QChannelMapping());
 
         // WHEN
-        simulateInitialization(&mapper, &backendMapper);
+        simulateInitializationSync(&mapper, &backendMapper);
         backendMapper.cleanup();
 
         // THEN
@@ -101,19 +101,18 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QChannelMapper mapper;
         Qt3DAnimation::Animation::Handler handler;
         Qt3DAnimation::Animation::ChannelMapper backendMapper;
         backendMapper.setHandler(&handler);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&mapper, &backendMapper);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendMapper.sceneChangeEvent(updateChange);
+        mapper.setEnabled(false);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
-        QCOMPARE(backendMapper.isEnabled(), true);
+        QCOMPARE(backendMapper.isEnabled(), false);
 
         // WHEN
         Qt3DAnimation::QChannelMapping mapping;
@@ -121,11 +120,10 @@ private Q_SLOTS:
         Qt3DAnimation::Animation::ChannelMapping *backendMapping
                 = handler.channelMappingManager()->getOrCreateResource(mappingId);
         backendMapping->setHandler(&handler);
-        simulateInitialization(&mapping, backendMapping);
+        simulateInitializationSync(&mapping, backendMapping);
 
-        auto nodeAddedChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &mapping);
-        nodeAddedChange->setPropertyName("mappings");
-        backendMapper.sceneChangeEvent(nodeAddedChange);
+        mapper.addMapping(&mapping);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
         QCOMPARE(backendMapper.mappingIds().size(), 1);
@@ -139,11 +137,10 @@ private Q_SLOTS:
         Qt3DAnimation::Animation::ChannelMapping *backendMapping2
                 = handler.channelMappingManager()->getOrCreateResource(mappingId2);
         backendMapping2->setHandler(&handler);
-        simulateInitialization(&mapping2, backendMapping2);
+        simulateInitializationSync(&mapping2, backendMapping2);
 
-        nodeAddedChange = Qt3DCore::QPropertyNodeAddedChangePtr::create(Qt3DCore::QNodeId(), &mapping2);
-        nodeAddedChange->setPropertyName("mappings");
-        backendMapper.sceneChangeEvent(nodeAddedChange);
+        mapper.addMapping(&mapping2);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
         QCOMPARE(backendMapper.mappingIds().size(), 2);
@@ -154,9 +151,8 @@ private Q_SLOTS:
         QCOMPARE(backendMapper.mappings().last(), backendMapping2);
 
         // WHEN
-        const auto nodeRemovedChange = Qt3DCore::QPropertyNodeRemovedChangePtr::create(Qt3DCore::QNodeId(), &mapping);
-        nodeRemovedChange->setPropertyName("mappings");
-        backendMapper.sceneChangeEvent(nodeRemovedChange);
+        mapper.removeMapping(&mapping);
+        backendMapper.syncFromFrontEnd(&mapper, false);
 
         // THEN
         QCOMPARE(backendMapper.mappingIds().size(), 1);
diff --git a/tests/auto/animation/channelmapping/tst_channelmapping.cpp b/tests/auto/animation/channelmapping/tst_channelmapping.cpp
index 35ffcb10a..e108e3d26 100644
--- a/tests/auto/animation/channelmapping/tst_channelmapping.cpp
+++ b/tests/auto/animation/channelmapping/tst_channelmapping.cpp
@@ -34,6 +34,7 @@
 #include <Qt3DAnimation/qskeletonmapping.h>
 #include <Qt3DAnimation/private/qchannelmapping_p.h>
 #include <Qt3DCore/qentity.h>
+#include <Qt3DCore/qtransform.h>
 #include <Qt3DCore/qskeleton.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
@@ -72,7 +73,7 @@ private Q_SLOTS:
         mapping.setProperty(QLatin1String("foo"));
 
         // WHEN
-        simulateInitialization(&mapping, &backendMapping);
+        simulateInitializationSync(&mapping, &backendMapping);
 
         // THEN
         QCOMPARE(backendMapping.peerId(), mapping.id());
@@ -93,7 +94,7 @@ private Q_SLOTS:
         skeletonMapping.setSkeleton(skeleton);
 
         // WHEN
-        simulateInitialization(&skeletonMapping, &backendSkeletonMapping);
+        simulateInitializationSync(&skeletonMapping, &backendSkeletonMapping);
 
         // THEN
         QCOMPARE(backendSkeletonMapping.peerId(), skeletonMapping.id());
@@ -128,7 +129,7 @@ private Q_SLOTS:
         mapping.setProperty(QLatin1String("foo"));
 
         // WHEN
-        simulateInitialization(&mapping, &backendMapping);
+        simulateInitializationSync(&mapping, &backendMapping);
         backendMapping.setSkeletonId(Qt3DCore::QNodeId::createId());
         backendMapping.cleanup();
 
@@ -146,77 +147,50 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QChannelMapping mapping;
         Qt3DAnimation::Animation::Handler handler;
         Qt3DAnimation::Animation::ChannelMapping backendMapping;
         backendMapping.setHandler(&handler);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&mapping, &backendMapping);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendMapping.sceneChangeEvent(updateChange);
+        mapping.setEnabled(false);
+        backendMapping.syncFromFrontEnd(&mapping, false);
 
         // THEN
-        QCOMPARE(backendMapping.isEnabled(), true);
+        QCOMPARE(backendMapping.isEnabled(), false);
 
         // WHEN
-        const QString channelName(QLatin1String("Rotation"));
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("channelName");
-        updateChange->setValue(channelName);
-        backendMapping.sceneChangeEvent(updateChange);
+        const QString channelName(QLatin1String("Translation"));
+        mapping.setChannelName(channelName);
+        backendMapping.syncFromFrontEnd(&mapping, false);
 
         // THEN
         QCOMPARE(backendMapping.channelName(), channelName);
 
         // WHEN
-        const auto id = Qt3DCore::QNodeId::createId();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("target");
-        updateChange->setValue(QVariant::fromValue(id));
-        backendMapping.sceneChangeEvent(updateChange);
-
-        // THEN
-        QCOMPARE(backendMapping.targetId(), id);
-
-        // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("type");
-        updateChange->setValue(QVariant(static_cast<int>(QVariant::Vector3D)));
-        backendMapping.sceneChangeEvent(updateChange);
+        const auto target = new Qt3DCore::QTransform();
+        mapping.setTarget(target);
+        mapping.setProperty("translation");
+        backendMapping.syncFromFrontEnd(&mapping, false);
 
         // THEN
+        QCOMPARE(backendMapping.targetId(), target->id());
         QCOMPARE(backendMapping.type(), static_cast<int>(QVariant::Vector3D));
+        QCOMPARE(backendMapping.componentCount(), 3);
 
-        // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("componentCount");
-        updateChange->setValue(4);
-        backendMapping.sceneChangeEvent(updateChange);
-
-        // THEN
-        QCOMPARE(backendMapping.componentCount(), 4);
-
-        // WHEN
-        const char *testName = "883";
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("propertyName");
-        updateChange->setValue(QVariant::fromValue(reinterpret_cast<void *>(const_cast<char *>(testName))));
-        backendMapping.sceneChangeEvent(updateChange);
-
-        // THEN
-        QCOMPARE(backendMapping.propertyName(), testName);
+        const char *testName = "translation";
+        QCOMPARE(qstrcmp(testName, backendMapping.propertyName()), 0);
 
-        // WHEN
-        const auto skeletonId = Qt3DCore::QNodeId::createId();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("skeleton");
-        updateChange->setValue(QVariant::fromValue(skeletonId));
-        backendMapping.sceneChangeEvent(updateChange);
+//        // WHEN
+//        const auto skeletonId = Qt3DCore::QNodeId::createId();
+//        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
+//        updateChange->setPropertyName("skeleton");
+//        updateChange->setValue(QVariant::fromValue(skeletonId));
+//        backendMapping.sceneChangeEvent(updateChange);
 
-        // THEN
-        QCOMPARE(backendMapping.skeletonId(), skeletonId);
+//        // THEN
+//        QCOMPARE(backendMapping.skeletonId(), skeletonId);
     }
 };
 
diff --git a/tests/auto/animation/clipanimator/tst_clipanimator.cpp b/tests/auto/animation/clipanimator/tst_clipanimator.cpp
index 0272bcfaa..5f297306a 100644
--- a/tests/auto/animation/clipanimator/tst_clipanimator.cpp
+++ b/tests/auto/animation/clipanimator/tst_clipanimator.cpp
@@ -29,6 +29,7 @@
 #include <QtTest/QTest>
 #include <Qt3DAnimation/private/clipanimator_p.h>
 #include <Qt3DAnimation/qanimationcliploader.h>
+#include <Qt3DAnimation/qchannelmapper.h>
 #include <Qt3DAnimation/qclipanimator.h>
 #include <Qt3DAnimation/qclock.h>
 #include <Qt3DCore/private/qnode_p.h>
@@ -59,7 +60,7 @@ private Q_SLOTS:
         animator.setNormalizedTime(0.5f);
 
         // WHEN
-        simulateInitialization(&animator, &backendAnimator);
+        simulateInitializationSync(&animator, &backendAnimator);
 
         // THEN
         QCOMPARE(backendAnimator.peerId(), animator.id());
@@ -98,7 +99,7 @@ private Q_SLOTS:
         animator.setNormalizedTime(1.0f);
 
         // WHEN
-        simulateInitialization(&animator, &backendAnimator);
+        simulateInitializationSync(&animator, &backendAnimator);
         backendAnimator.setClipId(Qt3DCore::QNodeId::createId());
         backendAnimator.setClockId(Qt3DCore::QNodeId::createId());
         backendAnimator.cleanup();
@@ -115,63 +116,60 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
+        Qt3DAnimation::QClipAnimator animator;
         Qt3DAnimation::Animation::Handler handler;
         Qt3DAnimation::Animation::ClipAnimator backendAnimator;
         backendAnimator.setHandler(&handler);
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange;
+        simulateInitializationSync(&animator, &backendAnimator);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("enabled");
-        updateChange->setValue(true);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setEnabled(false);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
-        QCOMPARE(backendAnimator.isEnabled(), true);
+        QCOMPARE(backendAnimator.isEnabled(), false);
 
         // WHEN
         auto newClip = new Qt3DAnimation::QAnimationClipLoader();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("clip");
-        updateChange->setValue(QVariant::fromValue(newClip->id()));
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setClip(newClip);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.clipId(), newClip->id());
 
         // WHEN
+        auto newMapper = new Qt3DAnimation::QChannelMapper();
+        animator.setChannelMapper(newMapper);
+        backendAnimator.syncFromFrontEnd(&animator, false);
+
+        // THEN
+        QCOMPARE(backendAnimator.mapperId(), newMapper->id());
+
+        // WHEN
         auto clock = new Qt3DAnimation::QClock();
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("clock");
-        updateChange->setValue(QVariant::fromValue(clock->id()));
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setClock(clock);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.clockId(), clock->id());
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("running");
-        updateChange->setValue(true);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setRunning(true);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.isRunning(), true);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("loops");
-        updateChange->setValue(64);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setLoopCount(64);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QCOMPARE(backendAnimator.loops(), 64);
 
         // WHEN
-        updateChange = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(Qt3DCore::QNodeId());
-        updateChange->setPropertyName("normalizedTime");
-        updateChange->setValue(0.5f);
-        backendAnimator.sceneChangeEvent(updateChange);
+        animator.setNormalizedTime(0.5f);
+        backendAnimator.syncFromFrontEnd(&animator, false);
 
         // THEN
         QVERIFY(qFuzzyCompare(backendAnimator.normalizedLocalTime(), 0.5f));
diff --git a/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp b/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp
index 3f705e713..54de87b1e 100644
--- a/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp
+++ b/tests/auto/animation/clipblendnodevisitor/tst_clipblendnodevisitor.cpp
@@ -73,11 +73,11 @@ private Q_SLOTS:
         manager.appendNode(childBlendNode12.id(), backendChildBlendNode12);
 
         // WHEN
-        simulateInitialization(&rootBlendNode, backendRootBlendNode);
-        simulateInitialization(&childBlendNode1, backendChildBlendNode1);
-        simulateInitialization(&childBlendNode2, backendChildBlendNode2);
-        simulateInitialization(&childBlendNode11, backendChildBlendNode11);
-        simulateInitialization(&childBlendNode12, backendChildBlendNode12);
+        simulateInitializationSync(&rootBlendNode, backendRootBlendNode);
+        simulateInitializationSync(&childBlendNode1, backendChildBlendNode1);
+        simulateInitializationSync(&childBlendNode2, backendChildBlendNode2);
+        simulateInitializationSync(&childBlendNode11, backendChildBlendNode11);
+        simulateInitializationSync(&childBlendNode12, backendChildBlendNode12);
 
         // THEN
         QCOMPARE(backendRootBlendNode->allDependencyIds().size(), 2);
@@ -121,7 +121,7 @@ private Q_SLOTS:
         // We purposely forgot the to do:  manager.appendNode(rootBlendNode.id(), backendRootBlendNode);
 
         // WHEN
-        simulateInitialization(&rootBlendNode, backendRootBlendNode);
+        simulateInitializationSync(&rootBlendNode, backendRootBlendNode);
 
         // THEN
         QCOMPARE(backendRootBlendNode->allDependencyIds().size(), 2);
@@ -159,9 +159,9 @@ private Q_SLOTS:
 
 
         // WHEN
-        simulateInitialization(&rootBlendNode, backendRootBlendNode);
-        simulateInitialization(&childBlendNode1, backendChildBlendNode1);
-        simulateInitialization(&childBlendNode2, backendChildBlendNode2);
+        simulateInitializationSync(&rootBlendNode, backendRootBlendNode);
+        simulateInitializationSync(&childBlendNode1, backendChildBlendNode1);
+        simulateInitializationSync(&childBlendNode2, backendChildBlendNode2);
 
         // THEN
         QCOMPARE(backendRootBlendNode->allDependencyIds().size(), 2);
diff --git a/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp b/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp
index 197378094..47f309b10 100644
--- a/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp
+++ b/tests/auto/animation/clipblendvalue/tst_clipblendvalue.cpp
@@ -80,7 +80,7 @@ private Q_SLOTS:
         {
             // WHEN
             ClipBlendValue backendClipBlendValue;
-            simulateInitialization(&clipBlendValue, &backendClipBlendValue);
+            simulateInitializationSync(&clipBlendValue, &backendClipBlendValue);
 
             // THEN
             QCOMPARE(backendClipBlendValue.isEnabled(), true);
@@ -91,7 +91,7 @@ private Q_SLOTS:
             // WHEN
             ClipBlendValue backendClipBlendValue;
             clipBlendValue.setEnabled(false);
-            simulateInitialization(&clipBlendValue, &backendClipBlendValue);
+            simulateInitializationSync(&clipBlendValue, &backendClipBlendValue);
 
             // THEN
             QCOMPARE(backendClipBlendValue.peerId(), clipBlendValue.id());
@@ -102,25 +102,23 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QClipBlendValue clipBlendValue;
         ClipBlendValue backendClipBlendValue;
+        simulateInitializationSync(&clipBlendValue, &backendClipBlendValue);
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendClipBlendValue.sceneChangeEvent(change);
+            clipBlendValue.setEnabled(newValue);
+            backendClipBlendValue.syncFromFrontEnd(&clipBlendValue, false);
 
             // THEN
             QCOMPARE(backendClipBlendValue.isEnabled(), newValue);
         }
         {
             // WHEN
-            const Qt3DAnimation::QAnimationClipLoader newValue;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("clip");
-            change->setValue(QVariant::fromValue(newValue.id()));
-            backendClipBlendValue.sceneChangeEvent(change);
+            Qt3DAnimation::QAnimationClipLoader newValue;
+            clipBlendValue.setClip(&newValue);
+            backendClipBlendValue.syncFromFrontEnd(&clipBlendValue, false);
 
             // THEN
             QCOMPARE(backendClipBlendValue.clipId(), newValue.id());
diff --git a/tests/auto/animation/clock/tst_clock.cpp b/tests/auto/animation/clock/tst_clock.cpp
index a81adfe7b..793a01b25 100644
--- a/tests/auto/animation/clock/tst_clock.cpp
+++ b/tests/auto/animation/clock/tst_clock.cpp
@@ -50,7 +50,7 @@ private Q_SLOTS:
         clock.setPlaybackRate(10.5);
 
         // WHEN
-        simulateInitialization(&clock, &backendClock);
+        simulateInitializationSync(&clock, &backendClock);
 
         // THEN
         QCOMPARE(backendClock.playbackRate(), clock.playbackRate());
@@ -69,7 +69,7 @@ private Q_SLOTS:
         clock.setPlaybackRate(10.5);
 
         // WHEN
-        simulateInitialization(&clock, &backendClock);
+        simulateInitializationSync(&clock, &backendClock);
         backendClock.cleanup();
 
         // THEN
@@ -79,15 +79,15 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QClock clock;
         Qt3DAnimation::Animation::Clock backendClock;
+        simulateInitializationSync(&clock, &backendClock);
 
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendClock.sceneChangeEvent(change);
+            clock.setEnabled(newValue);
+            backendClock.syncFromFrontEnd(&clock, false);
 
             // THEN
             QCOMPARE(backendClock.isEnabled(), newValue);
@@ -95,10 +95,8 @@ private Q_SLOTS:
         {
             // WHEN
             const double newPlaybackRateValue = 2.0;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("playbackRate");
-            change->setValue(newPlaybackRateValue);
-            backendClock.sceneChangeEvent(change);
+            clock.setPlaybackRate(newPlaybackRateValue);
+            backendClock.syncFromFrontEnd(&clock, false);
 
             // THEN
             QCOMPARE(backendClock.playbackRate(), newPlaybackRateValue);
diff --git a/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp b/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp
index e75c4f2f8..732a87770 100644
--- a/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp
+++ b/tests/auto/animation/lerpclipblend/tst_lerpclipblend.cpp
@@ -137,7 +137,7 @@ private Q_SLOTS:
         {
             // WHEN
             LerpClipBlend backendLerpBlend;
-            simulateInitialization(&lerpBlend, &backendLerpBlend);
+            simulateInitializationSync(&lerpBlend, &backendLerpBlend);
 
             // THEN
             QCOMPARE(backendLerpBlend.isEnabled(), true);
@@ -148,7 +148,7 @@ private Q_SLOTS:
             // WHEN
             LerpClipBlend backendLerpBlend;
             lerpBlend.setEnabled(false);
-            simulateInitialization(&lerpBlend, &backendLerpBlend);
+            simulateInitializationSync(&lerpBlend, &backendLerpBlend);
 
             // THEN
             QCOMPARE(backendLerpBlend.peerId(), lerpBlend.id());
@@ -159,27 +159,26 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DAnimation::QLerpClipBlend lerpBlend;
         LerpClipBlend backendLerpBlend;
+        simulateInitializationSync(&lerpBlend, &backendLerpBlend);
+
         {
-             // WHEN
-             const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendLerpBlend.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = false;
+            lerpBlend.setEnabled(newValue);
+            backendLerpBlend.syncFromFrontEnd(&lerpBlend, false);
+
+            // THEN
             QCOMPARE(backendLerpBlend.isEnabled(), newValue);
         }
         {
-             // WHEN
-             const float newValue = 0.883f;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("blendFactor");
-             change->setValue(QVariant::fromValue(newValue));
-             backendLerpBlend.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const float newValue = 0.883f;
+            lerpBlend.setBlendFactor(newValue);
+            backendLerpBlend.syncFromFrontEnd(&lerpBlend, false);
+
+            // THEN
             QCOMPARE(backendLerpBlend.blendFactor(), newValue);
         }
     }
diff --git a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
index d217f3b0f..591ff54ce 100644
--- a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
+++ b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
@@ -185,23 +185,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 3);
-            auto change = arbiter.events.at(0).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "type");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), int(QVariant::Vector3D));
-
-            change = arbiter.events.at(1).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "callback");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(reinterpret_cast<DummyCallback *>(change->value().value<void *>()), callback);
-
-            change = arbiter.events.at(2).staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "callbackFlags");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), static_cast<int>(Qt3DAnimation::QAnimationCallback::OnThreadPool));
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setCallback(QVariant::Vector3D, callback, Qt3DAnimation::QAnimationCallback::OnThreadPool);
@@ -209,6 +197,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 };
diff --git a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
index 37bd3e241..a47061077 100644
--- a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
+++ b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
@@ -284,24 +284,11 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 3);
-
-            auto change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "type");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), static_cast<int>(QVariant::Vector3D));
-
-            change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "componentCount");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QCOMPARE(change->value().toInt(), 3);
-
-            change = arbiter.events.takeFirst().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-            QCOMPARE(change->propertyName(), "propertyName");
-            QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-            QVERIFY(qstrcmp(reinterpret_cast<const char *>(change->value().value<void *>()), "scale") == 0);
+            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
 
-            arbiter.events.clear();
+            arbiter.dirtyNodes.clear();
 
             // WHEN
             mapping.setProperty(QStringLiteral("scale"));
@@ -309,6 +296,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 0);
         }
     }
 
@@ -340,8 +328,8 @@ private Q_SLOTS:
         QFETCH(int, expectedType);
         QFETCH(int, expectedComponentCount);
 
-        Q_UNUSED(expectedType);
-        Q_UNUSED(expectedComponentCount);
+        Q_UNUSED(expectedType)
+        Q_UNUSED(expectedComponentCount)
 
         TestArbiter arbiter;
         Qt3DAnimation::QChannelMapping mapping;
@@ -363,7 +351,7 @@ private Q_SLOTS:
             mapping.setProperty(QString::fromLatin1(propertyName));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes.size(), 1);
         }
     }
 
diff --git a/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp b/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp
index b10c2e88e..f7a6ce214 100644
--- a/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp
+++ b/tests/auto/render/blitframebuffer/tst_blitframebuffer.cpp
@@ -78,7 +78,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer;
             backendBlitFramebuffer.setRenderer(&renderer);
-            simulateInitialization(&blitFramebuffer, &backendBlitFramebuffer);
+            simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer);
 
             // THEN
             QCOMPARE(backendBlitFramebuffer.isEnabled(), true);
@@ -98,7 +98,7 @@ private Q_SLOTS:
             Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer;
             backendBlitFramebuffer.setRenderer(&renderer);
             blitFramebuffer.setEnabled(false);
-            simulateInitialization(&blitFramebuffer, &backendBlitFramebuffer);
+            simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer);
 
             // THEN
             QCOMPARE(backendBlitFramebuffer.peerId(), blitFramebuffer.id());
@@ -111,98 +111,84 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::BlitFramebuffer backendBlitFramebuffer;
+        Qt3DRender::QBlitFramebuffer blitFramebuffer;
         TestRenderer renderer;
         backendBlitFramebuffer.setRenderer(&renderer);
+        simulateInitializationSync(&blitFramebuffer, &backendBlitFramebuffer);
 
         {
-             // WHEN
-             const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendBlitFramebuffer.sceneChangeEvent(change);
-
-             // THEN
+            // WHEN
+            const bool newValue = false;
+            blitFramebuffer.setEnabled(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
+
+            // THEN
             QCOMPARE(backendBlitFramebuffer.isEnabled(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
-            const Qt3DRender::QRenderTarget sourceRenderTarget;
-            const Qt3DCore::QNodeId newValue = sourceRenderTarget.id();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("sourceRenderTarget");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlitFramebuffer.sourceRenderTargetId(), newValue);
+            // WHEN
+            Qt3DRender::QRenderTarget sourceRenderTarget;
+            blitFramebuffer.setSource(&sourceRenderTarget);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
+
+            // THEN
+            QCOMPARE(backendBlitFramebuffer.sourceRenderTargetId(), sourceRenderTarget.id());
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
-            const Qt3DRender::QRenderTarget destinationRenderTarget;
-            const Qt3DCore::QNodeId newValue = destinationRenderTarget.id();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("destinationRenderTarget");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
-
-             // THEN
-            QCOMPARE(backendBlitFramebuffer.destinationRenderTargetId(), newValue);
+            // WHEN
+            Qt3DRender::QRenderTarget destinationRenderTarget;
+            blitFramebuffer.setDestination(&destinationRenderTarget);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
+
+            // THEN
+            QCOMPARE(backendBlitFramebuffer.destinationRenderTargetId(), destinationRenderTarget.id());
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = QRect(0,0,1,1);
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("sourceRect");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setSourceRect(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.sourceRect(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = QRect(0,0,1,1);
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("destinationRect");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setDestinationRect(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.destinationRect(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = Qt3DRender::QRenderTargetOutput::Color1;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("sourceAttachmentPoint");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setSourceAttachmentPoint(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.sourceAttachmentPoint(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
         {
-             // WHEN
+            // WHEN
             const auto newValue = Qt3DRender::QRenderTargetOutput::Color1;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("destinationAttachmentPoint");
-             change->setValue(QVariant::fromValue(newValue));
-             backendBlitFramebuffer.sceneChangeEvent(change);
+            blitFramebuffer.setDestinationAttachmentPoint(newValue);
+            backendBlitFramebuffer.syncFromFrontEnd(&blitFramebuffer, false);
 
-             // THEN
+            // THEN
             QCOMPARE(backendBlitFramebuffer.destinationAttachmentPoint(), newValue);
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
index f1c228f17..80298780a 100644
--- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
+++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
@@ -55,7 +55,6 @@
 #include <Qt3DRender/private/calcboundingvolumejob_p.h>
 #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h>
 #include <Qt3DRender/private/loadbufferjob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
 #include <Qt3DRender/private/geometryrenderermanager_p.h>
 #include <Qt3DRender/private/sphere_p.h>
@@ -157,10 +156,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/entity/tst_entity.cpp b/tests/auto/render/entity/tst_entity.cpp
index 7e5150a77..463fbbb79 100644
--- a/tests/auto/render/entity/tst_entity.cpp
+++ b/tests/auto/render/entity/tst_entity.cpp
@@ -182,7 +182,6 @@ private slots:
         entity.cleanup();
 
         // THEN
-        QVERIFY(entity.parentEntityId().isNull());
         QVERIFY(entity.componentUuid<Transform>().isNull());
         QVERIFY(entity.componentUuid<CameraLens>().isNull());
         QVERIFY(entity.componentUuid<Material>().isNull());
@@ -201,29 +200,18 @@ private slots:
         QVERIFY(!containsAll);
     }
 
-    void checkRebuildingEntityHierarchy()
+    void checkEntityReparenting()
     {
         // GIVEN
         TestRenderer renderer;
         NodeManagers nodeManagers;
         Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC;
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            Entity *entity = nodeManagers.renderNodesManager()->getOrCreateResource(frontEndEntity.id());
-            entity->setNodeManagers(&nodeManagers);
-            entity->setRenderer(&renderer);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         // THEN
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId().isNull());
-        QVERIFY(backendC->parentEntityId().isNull());
-
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == nullptr);
         QVERIFY(backendC->parent() == nullptr);
@@ -233,9 +221,6 @@ private slots:
         QVERIFY(backendC->childrenHandles().isEmpty());
 
         // WHEN
-        renderer.clearDirtyBits(0);
-        QVERIFY(renderer.dirtyBits() == 0);
-
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
             backendEntity->syncFromFrontEnd(&entity, false);
@@ -248,68 +233,111 @@ private slots:
         sendParentChange(frontendEntityC);
 
         // THEN
-        QVERIFY(renderer.dirtyBits() & AbstractRenderer::EntityHierarchyDirty);
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == backendA);
+        QVERIFY(backendC->parent() == backendB);
 
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId() == frontendEntityA.id());
-        QVERIFY(backendC->parentEntityId() == frontendEntityB.id());
+        QCOMPARE(backendA->childrenHandles().count(), 1);
+        QCOMPARE(backendB->childrenHandles().count(), 1);
+        QVERIFY(backendC->childrenHandles().isEmpty());
 
+          // WHEN - reparent C to A
+        frontendEntityC.setParent(&frontendEntityA);
+        sendParentChange(frontendEntityC);
+
+        // THEN
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == backendA);
+        QVERIFY(backendC->parent() == backendA);
+
+        QCOMPARE(backendA->childrenHandles().size(), 2);
+        QVERIFY(backendB->childrenHandles().isEmpty());
+        QVERIFY(backendC->childrenHandles().isEmpty());
+
+        // WHEN - reparent B to null.
+        frontendEntityB.setParent(static_cast<Qt3DCore::QNode *>(nullptr));
+        sendParentChange(frontendEntityB);
+
+        // THEN
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == nullptr);
-        QVERIFY(backendC->parent() == nullptr);
+        QVERIFY(backendC->parent() == backendA);
 
-        QVERIFY(backendA->childrenHandles().isEmpty());
+        QCOMPARE(backendA->childrenHandles().count(), 1);
+        QVERIFY(!backendA->childrenHandles().contains(backendB->handle()));
         QVERIFY(backendB->childrenHandles().isEmpty());
         QVERIFY(backendC->childrenHandles().isEmpty());
+      }
+
+    void checkEntityCleanup()
+    {
+        // GIVEN
+        TestRenderer renderer;
+        NodeManagers nodeManagers;
+        Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC;
+
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         // WHEN
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
+        auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
+            Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
+            backendEntity->syncFromFrontEnd(&entity, false);
         };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
+
+        // reparent B and C to A.
+        frontendEntityB.setParent(&frontendEntityA);
+        sendParentChange(frontendEntityB);
+        frontendEntityC.setParent(&frontendEntityA);
+        sendParentChange(frontendEntityC);
 
         // THEN
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == backendA);
-        QVERIFY(backendC->parent() == backendB);
+        QVERIFY(backendC->parent() == backendA);
 
-        QVERIFY(!backendA->childrenHandles().isEmpty());
-        QVERIFY(!backendB->childrenHandles().isEmpty());
+        QCOMPARE(backendA->childrenHandles().count(), 2);
+        QVERIFY(backendB->childrenHandles().isEmpty());
         QVERIFY(backendC->childrenHandles().isEmpty());
 
-        // WHEN - reparent B to null.
-        frontendEntityB.setParent(static_cast<Qt3DCore::QNode *>(nullptr));
-        sendParentChange(frontendEntityB);
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
+        // WHEN - cleaning up a child
+        backendC->cleanup();
+
+        // THEN - the child's parent should be null and it
+        // should be removed from its parent's list of children
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == backendA);
+        QVERIFY(backendC->parent() == nullptr);
+
+        QCOMPARE(backendA->childrenHandles().count(), 1);
+        QVERIFY(!backendA->childrenHandles().contains(backendC->handle()));
+        QVERIFY(backendB->childrenHandles().isEmpty());
+        QVERIFY(backendC->childrenHandles().isEmpty());
 
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId().isNull());
-        QVERIFY(backendC->parentEntityId() == frontendEntityB.id());
+        // WHEN (cleaning up parent)
+        backendA->cleanup();
 
+        // THEN  (it's children's parent should be set to null)
         QVERIFY(backendA->parent() == nullptr);
         QVERIFY(backendB->parent() == nullptr);
-        QVERIFY(backendC->parent() == backendB);
+        QVERIFY(backendC->parent() == nullptr);
 
         QVERIFY(backendA->childrenHandles().isEmpty());
-        QVERIFY(!backendB->childrenHandles().isEmpty());
+        QVERIFY(backendB->childrenHandles().isEmpty());
         QVERIFY(backendC->childrenHandles().isEmpty());
 
-        // WHEN - cleanup
-        backendA->cleanup();
+        // WHEN
         backendB->cleanup();
-        backendC->cleanup();
 
-        // THEN
-        QVERIFY(backendA->parentEntityId().isNull());
-        QVERIFY(backendB->parentEntityId().isNull());
-        QVERIFY(backendC->parentEntityId().isNull());
+        // THEN nothing should change
+        QVERIFY(backendA->childrenHandles().isEmpty());
+        QVERIFY(backendB->childrenHandles().isEmpty());
+        QVERIFY(backendC->childrenHandles().isEmpty());
 
-        QVERIFY(renderer.dirtyBits() != 0);
+        QVERIFY(backendA->parent() == nullptr);
+        QVERIFY(backendB->parent() == nullptr);
+        QVERIFY(backendC->parent() == nullptr);
     }
 
     void shouldHandleSingleComponentEvents_data()
@@ -441,19 +469,9 @@ private slots:
         NodeManagers nodeManagers;
         Qt3DCore::QEntity frontendEntityA, frontendEntityB, frontendEntityC;
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
-            Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
-            entity->setNodeManagers(&nodeManagers);
-            entity->setHandle(renderNodeHandle);
-            entity->setRenderer(&renderer);
-            entity->syncFromFrontEnd(&frontEndEntity, true);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
@@ -466,14 +484,6 @@ private slots:
         frontendEntityC.setParent(&frontendEntityB);
         sendParentChange(frontendEntityC);
 
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
-        };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
-
         // WHEN
         int visitCount = 0;
         auto counter = [&visitCount](const Entity *) { ++visitCount; };
@@ -494,19 +504,9 @@ private slots:
         frontendEntityB.setEnabled(false);
         frontendEntityC.setEnabled(false);
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
-            Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
-            entity->setNodeManagers(&nodeManagers);
-            entity->setHandle(renderNodeHandle);
-            entity->setRenderer(&renderer);
-            entity->syncFromFrontEnd(&frontEndEntity, true);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
@@ -519,14 +519,6 @@ private slots:
         frontendEntityC.setParent(&frontendEntityB);
         sendParentChange(frontendEntityC);
 
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
-        };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
-
        // WHEN
        CompleteVisitor v1(&nodeManagers);
        EnabledVisitor v2(&nodeManagers);
@@ -553,19 +545,9 @@ private slots:
         frontendEntityB.setEnabled(false);
         frontendEntityC.setEnabled(false);
 
-        auto entityCreator = [&nodeManagers, &renderer](const Qt3DCore::QEntity &frontEndEntity) {
-            HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
-            Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
-            entity->setNodeManagers(&nodeManagers);
-            entity->setHandle(renderNodeHandle);
-            entity->setRenderer(&renderer);
-            entity->syncFromFrontEnd(&frontEndEntity, true);
-            return entity;
-        };
-
-        auto backendA = entityCreator(frontendEntityA);
-        auto backendB = entityCreator(frontendEntityB);
-        auto backendC = entityCreator(frontendEntityC);
+        auto backendA = createEntity(renderer, nodeManagers, frontendEntityA);
+        auto backendB = createEntity(renderer, nodeManagers, frontendEntityB);
+        auto backendC = createEntity(renderer, nodeManagers, frontendEntityC);
 
         auto sendParentChange = [&nodeManagers](const Qt3DCore::QEntity &entity) {
             Entity *backendEntity = nodeManagers.renderNodesManager()->getOrCreateResource(entity.id());
@@ -578,14 +560,6 @@ private slots:
         frontendEntityC.setParent(&frontendEntityB);
         sendParentChange(frontendEntityC);
 
-        auto rebuildHierarchy = [](Entity *backend) {
-            backend->clearEntityHierarchy();
-            backend->rebuildEntityHierarchy();
-        };
-        rebuildHierarchy(backendA);
-        rebuildHierarchy(backendB);
-        rebuildHierarchy(backendC);
-
         // WHEN
         EntityAccumulator v1(&nodeManagers);
         EntityAccumulator v2([](Entity *e) { return e->isEnabled(); }, &nodeManagers);
@@ -596,6 +570,18 @@ private slots:
         QCOMPARE(r1.count(), 3);
         QCOMPARE(r2.count(), 0);
     }
+
+private:
+    Entity *createEntity(TestRenderer &renderer, NodeManagers &nodeManagers, const Qt3DCore::QEntity &frontEndEntity) {
+        HEntity renderNodeHandle = nodeManagers.renderNodesManager()->getOrAcquireHandle(frontEndEntity.id());
+        Entity *entity = nodeManagers.renderNodesManager()->data(renderNodeHandle);
+        entity->setNodeManagers(&nodeManagers);
+        entity->setHandle(renderNodeHandle);
+        entity->setRenderer(&renderer);
+        entity->syncFromFrontEnd(&frontEndEntity, true);
+        return entity;
+    }
+
 };
 
 QTEST_APPLESS_MAIN(tst_RenderEntity)
diff --git a/tests/auto/render/framegraphnode/framegraphnode.pro b/tests/auto/render/framegraphnode/framegraphnode.pro
index 577bc9775..f47fc1866 100644
--- a/tests/auto/render/framegraphnode/framegraphnode.pro
+++ b/tests/auto/render/framegraphnode/framegraphnode.pro
@@ -8,3 +8,4 @@ CONFIG += testcase
 SOURCES += tst_framegraphnode.cpp
 
 include(../commons/commons.pri)
+include(../../core/common/common.pri)
diff --git a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
index 22bd872dc..4ad1ce6f5 100644
--- a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
+++ b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
@@ -33,6 +33,7 @@
 #include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include "testrenderer.h"
+#include "qbackendnodetester.h"
 
 class MyFrameGraphNode : public Qt3DRender::Render::FrameGraphNode
 {
@@ -52,12 +53,12 @@ public:
     {}
 };
 
-class tst_FrameGraphNode : public QObject
+class tst_FrameGraphNode : public  Qt3DCore::QBackendNodeTester
 {
     Q_OBJECT
 public:
     tst_FrameGraphNode(QObject *parent = nullptr)
-        : QObject(parent)
+        : Qt3DCore::QBackendNodeTester(parent)
     {}
 
     ~tst_FrameGraphNode()
@@ -216,10 +217,9 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
-        const Qt3DCore::QNodeId fgNode1Id = Qt3DCore::QNodeId::createId();
-
-        Qt3DRender::Render::FrameGraphNode *backendFGNode = new MyFrameGraphNode();
+        Qt3DRender::QFrameGraphNode *frontendFGNode = new MyQFrameGraphNode();
         Qt3DRender::QFrameGraphNode *frontendFGChild = new MyQFrameGraphNode();
+        Qt3DRender::Render::FrameGraphNode *backendFGNode = new MyFrameGraphNode();
         Qt3DRender::Render::FrameGraphNode *backendFGChild = new MyFrameGraphNode();
 
         QScopedPointer<Qt3DRender::Render::FrameGraphManager> manager(new Qt3DRender::Render::FrameGraphManager());
@@ -229,44 +229,41 @@ private Q_SLOTS:
         backendFGNode->setRenderer(&renderer);
         backendFGChild->setRenderer(&renderer);
 
-        setIdInternal(backendFGNode, fgNode1Id);
+        setIdInternal(backendFGNode, frontendFGNode->id());
         setIdInternal(backendFGChild, frontendFGChild->id());
 
-        manager->appendNode(fgNode1Id, backendFGNode);
+        manager->appendNode(frontendFGNode->id(), backendFGNode);
         manager->appendNode(frontendFGChild->id(), backendFGChild);
 
         backendFGNode->setFrameGraphManager(manager.data());
         backendFGChild->setFrameGraphManager(manager.data());
 
-
-        // To geneate the type_info in the QNodePrivate of frontendFGChild
-        Qt3DCore::QNodeCreatedChangeGenerator generator(frontendFGChild);
+        simulateInitializationSync(frontendFGNode, backendFGNode);
+        simulateInitializationSync(frontendFGChild, backendFGChild);
 
         QCOMPARE(backendFGNode->childrenIds().size(), 0);
 
         {
             // WHEN
-            renderer.clearDirtyBits(0);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(frontendFGChild->id());
-            change->setPropertyName("parentFrameGraphUpdated");
-            change->setValue(QVariant::fromValue(fgNode1Id));
-            backendFGChild->sceneChangeEvent(change);
+            renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+            frontendFGChild->setParent(frontendFGNode);
+            backendFGChild->syncFromFrontEnd(frontendFGChild, false);
 
             // THEN
             QCOMPARE(backendFGNode->childrenIds().size(), 1);
-            QCOMPARE(backendFGChild->parentId(), fgNode1Id);
+            QCOMPARE(backendFGChild->parentId(), frontendFGNode->id());
+            QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
         }
         {
             // WHEN
-            renderer.clearDirtyBits(0);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(frontendFGChild->id());
-            change->setPropertyName("parentFrameGraphUpdated");
-            change->setValue(QVariant::fromValue(Qt3DCore::QNodeId()));
-            backendFGChild->sceneChangeEvent(change);
+            renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
+            frontendFGChild->setParent(Q_NODE_NULLPTR);
+            backendFGChild->syncFromFrontEnd(frontendFGChild, false);
 
             // THEN
             QCOMPARE(backendFGNode->childrenIds().size(), 0);
             QVERIFY(backendFGChild->parentId().isNull());
+            QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
         }
     }
 
diff --git a/tests/auto/render/layerfiltering/tst_layerfiltering.cpp b/tests/auto/render/layerfiltering/tst_layerfiltering.cpp
index 8c72829e0..255ff5ea8 100644
--- a/tests/auto/render/layerfiltering/tst_layerfiltering.cpp
+++ b/tests/auto/render/layerfiltering/tst_layerfiltering.cpp
@@ -33,7 +33,6 @@
 #include <Qt3DRender/private/entity_p.h>
 #include <Qt3DRender/private/filterlayerentityjob_p.h>
 #include <Qt3DRender/private/updatetreeenabledjob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/qlayer.h>
 #include <Qt3DRender/qlayerfilter.h>
 #include "testaspect.h"
@@ -634,10 +633,6 @@ private Q_SLOTS:
         // WHEN
         Qt3DRender::Render::Entity *backendRoot = aspect->nodeManagers()->renderNodesManager()->getOrCreateResource(entitySubtree->id());
 
-        Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-        updateEntitiesJob.setManager(aspect->nodeManagers());
-        updateEntitiesJob.run();
-
         Qt3DRender::Render::UpdateTreeEnabledJob updateTreeEnabledJob;
         updateTreeEnabledJob.setRoot(backendRoot);
         updateTreeEnabledJob.setManagers(aspect->nodeManagers());
diff --git a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp
index 71cf3f567..708659e4e 100644
--- a/tests/auto/render/memorybarrier/tst_memorybarrier.cpp
+++ b/tests/auto/render/memorybarrier/tst_memorybarrier.cpp
@@ -64,7 +64,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::MemoryBarrier backendMemoryBarrier;
             backendMemoryBarrier.setRenderer(&renderer);
-            simulateInitialization(&memoryBarrier, &backendMemoryBarrier);
+            simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier);
 
             // THEN
             QCOMPARE(backendMemoryBarrier.isEnabled(), true);
@@ -78,7 +78,7 @@ private Q_SLOTS:
             Qt3DRender::Render::MemoryBarrier backendMemoryBarrier;
             backendMemoryBarrier.setRenderer(&renderer);
             memoryBarrier.setEnabled(false);
-            simulateInitialization(&memoryBarrier, &backendMemoryBarrier);
+            simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier);
 
             // THEN
             QCOMPARE(backendMemoryBarrier.peerId(), memoryBarrier.id());
@@ -93,14 +93,15 @@ private Q_SLOTS:
         Qt3DRender::Render::MemoryBarrier backendMemoryBarrier;
         TestRenderer renderer;
         backendMemoryBarrier.setRenderer(&renderer);
+        Qt3DRender::QMemoryBarrier memoryBarrier;
+
+        simulateInitializationSync(&memoryBarrier, &backendMemoryBarrier);
 
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendMemoryBarrier.sceneChangeEvent(change);
+             memoryBarrier.setEnabled(newValue);
+             backendMemoryBarrier.syncFromFrontEnd(&memoryBarrier, false);
 
              // THEN
             QCOMPARE(backendMemoryBarrier.isEnabled(), newValue);
@@ -110,10 +111,8 @@ private Q_SLOTS:
         {
              // WHEN
              const Qt3DRender::QMemoryBarrier::Operations newValue(Qt3DRender::QMemoryBarrier::AtomicCounter|Qt3DRender::QMemoryBarrier::ElementArray);
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("waitOperations");
-             change->setValue(QVariant::fromValue(newValue));
-             backendMemoryBarrier.sceneChangeEvent(change);
+             memoryBarrier.setWaitOperations(newValue);
+             backendMemoryBarrier.syncFromFrontEnd(&memoryBarrier, false);
 
              // THEN
             QCOMPARE(backendMemoryBarrier.waitOperations(), newValue);
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index a8ffa9712..1fbdc4d04 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -48,7 +48,6 @@
 #include <Qt3DRender/private/qrenderaspect_p.h>
 #include <Qt3DRender/private/pickboundingvolumejob_p.h>
 #include <Qt3DRender/private/pickboundingvolumeutils_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/updatemeshtrianglelistjob_p.h>
 #include <Qt3DRender/private/updateworldboundingvolumejob_p.h>
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
@@ -150,10 +149,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/proximityfilter/tst_proximityfilter.cpp b/tests/auto/render/proximityfilter/tst_proximityfilter.cpp
index c1f1e8ec4..88059e31a 100644
--- a/tests/auto/render/proximityfilter/tst_proximityfilter.cpp
+++ b/tests/auto/render/proximityfilter/tst_proximityfilter.cpp
@@ -66,7 +66,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::ProximityFilter backendProximityFilter;
             backendProximityFilter.setRenderer(&renderer);
-            simulateInitialization(&proximityFilter, &backendProximityFilter);
+            simulateInitializationSync(&proximityFilter, &backendProximityFilter);
 
             // THEN
             QCOMPARE(backendProximityFilter.isEnabled(), true);
@@ -81,7 +81,7 @@ private Q_SLOTS:
             Qt3DRender::Render::ProximityFilter backendProximityFilter;
             backendProximityFilter.setRenderer(&renderer);
             proximityFilter.setEnabled(false);
-            simulateInitialization(&proximityFilter, &backendProximityFilter);
+            simulateInitializationSync(&proximityFilter, &backendProximityFilter);
 
             // THEN
             QCOMPARE(backendProximityFilter.peerId(), proximityFilter.id());
@@ -93,17 +93,17 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DRender::QProximityFilter proximityFilter;
         Qt3DRender::Render::ProximityFilter backendProximityFilter;
         TestRenderer renderer;
         backendProximityFilter.setRenderer(&renderer);
+        simulateInitializationSync(&proximityFilter, &backendProximityFilter);
 
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendProximityFilter.sceneChangeEvent(change);
+             proximityFilter.setEnabled(newValue);
+             backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter);
 
              // THEN
             QCOMPARE(backendProximityFilter.isEnabled(), newValue);
@@ -113,10 +113,9 @@ private Q_SLOTS:
         {
              // WHEN
              const float newValue = 383.0f;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("distanceThreshold");
-             change->setValue(QVariant::fromValue(newValue));
-             backendProximityFilter.sceneChangeEvent(change);
+             proximityFilter.setDistanceThreshold(newValue);
+             backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter);
+
 
              // THEN
             QCOMPARE(backendProximityFilter.distanceThreshold(), newValue);
@@ -125,14 +124,12 @@ private Q_SLOTS:
         }
         {
              // WHEN
-             const Qt3DCore::QNodeId newValue = Qt3DCore::QNodeId::createId();
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("entity");
-             change->setValue(QVariant::fromValue(newValue));
-             backendProximityFilter.sceneChangeEvent(change);
+             Qt3DCore::QEntity e;
+             proximityFilter.setEntity(&e);
+             backendProximityFilter.syncFromFrontEnd(&proximityFilter, &backendProximityFilter);
 
              // THEN
-            QCOMPARE(backendProximityFilter.entityId(), newValue);
+            QCOMPARE(backendProximityFilter.entityId(), e.id());
             QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
diff --git a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
index c8d862b2e..07adf12b5 100644
--- a/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
+++ b/tests/auto/render/proximityfiltering/tst_proximityfiltering.cpp
@@ -247,10 +247,6 @@ private Q_SLOTS:
         // WHEN
         Qt3DRender::Render::Entity *backendRoot = aspect->nodeManagers()->renderNodesManager()->getOrCreateResource(entitySubtree->id());
 
-        Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-        updateEntitiesJob.setManager(aspect->nodeManagers());
-        updateEntitiesJob.run();
-
         Qt3DRender::Render::UpdateTreeEnabledJob updateTreeEnabledJob;
         updateTreeEnabledJob.setRoot(backendRoot);
         updateTreeEnabledJob.setManagers(aspect->nodeManagers());
diff --git a/tests/auto/render/qcamera/tst_qcamera.cpp b/tests/auto/render/qcamera/tst_qcamera.cpp
index 4d424a420..229dff565 100644
--- a/tests/auto/render/qcamera/tst_qcamera.cpp
+++ b/tests/auto/render/qcamera/tst_qcamera.cpp
@@ -34,7 +34,6 @@
 #include <qbackendnodetester.h>
 
 #include <Qt3DCore/QEntity>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DCore/private/qaspectjobmanager_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
 #include <Qt3DCore/qpropertyupdatedchange.h>
@@ -141,10 +140,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
index c7686bae2..4bc766b58 100644
--- a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
+++ b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
@@ -119,14 +119,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto addChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(addChange->propertyName(), "layer");
-        QCOMPARE(addChange->subjectId(), layerFilter->id());
-        QCOMPARE(addChange->addedNodeId(), layerFilter->layers().at(0)->id());
-        QCOMPARE(addChange->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         layer = new Qt3DRender::QLayer(layerFilter.data());
@@ -135,14 +132,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        addChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(addChange->propertyName(), "layer");
-        QCOMPARE(addChange->subjectId(), layerFilter->id());
-        QCOMPARE(addChange->addedNodeId(), layerFilter->layers().at(1)->id());
-        QCOMPARE(addChange->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         layer = layerFilter->layers().at(0);
@@ -150,14 +144,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto removeChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(removeChange->propertyName(), "layer");
-        QCOMPARE(removeChange->subjectId(), layerFilter->id());
-        QCOMPARE(removeChange->removedNodeId(), layer->id());
-        QCOMPARE(removeChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkLayerBookkeeping()
diff --git a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
index 2fab1e837..b9cb2230f 100644
--- a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
+++ b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
@@ -72,17 +72,11 @@ private Q_SLOTS:
         QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture(QRect(10, 15, 20, 50)));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "renderCaptureRequest");
-        QCOMPARE(change->subjectId(),renderCapture->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-        QVERIFY(change->value().canConvert<Qt3DRender::QRenderCaptureRequest>());
-        const Qt3DRender::QRenderCaptureRequest request = change->value().value<Qt3DRender::QRenderCaptureRequest>();
-        QCOMPARE(request.captureId, 1);
-        QCOMPARE(request.rect, QRect(10, 15, 20, 50));
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderCapture.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkRenderCaptureReply()
diff --git a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
index 23544c0c6..f08846ba3 100644
--- a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
+++ b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
@@ -154,14 +154,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "parameter");
-        QCOMPARE(change->subjectId(),renderPassFilter->id());
-        QCOMPARE(change->addedNodeId(), param1->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         renderPassFilter->addParameter(param1);
@@ -169,20 +166,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         renderPassFilter->removeParameter(param1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "parameter");
-        QCOMPARE(nodeRemovedChange->subjectId(), renderPassFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), param1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
@@ -190,14 +185,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "match");
-        QCOMPARE(change->subjectId(),renderPassFilter->id());
-        QCOMPARE(change->addedNodeId(), filterKey1->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         renderPassFilter->addMatch(filterKey1);
@@ -205,20 +197,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         renderPassFilter->removeMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "match");
-        QCOMPARE(nodeRemovedChange->subjectId(), renderPassFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), filterKey1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkParameterBookkeeping()
diff --git a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
index 6b200d19d..9eb97ce93 100644
--- a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
+++ b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
@@ -140,14 +140,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(change->propertyName(), "renderState");
-        QCOMPARE(change->subjectId(), stateSet->id());
-        QCOMPARE(change->addedNodeId(), state1->id());
-        QCOMPARE(change->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(stateSet.data()));
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         stateSet->addRenderState(state1);
@@ -155,20 +152,17 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
-
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
         // WHEN
         stateSet->removeRenderState(state1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "renderState");
-        QCOMPARE(nodeRemovedChange->subjectId(), stateSet->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), state1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QVERIFY(arbiter.dirtyNodes.contains(stateSet.data()));
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkRenderStateBookkeeping()
diff --git a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
index f525f1254..7bacc3b6d 100644
--- a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
+++ b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
@@ -149,14 +149,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        auto change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "outputs");
-        QCOMPARE(change->subjectId(), renderTargetSelector->id());
-        QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), outputs);
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
 
-        arbiter.events.clear();
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         renderTargetSelector->setOutputs(outputs);
@@ -164,20 +161,18 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         renderTargetSelector->setOutputs(QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>());
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "outputs");
-        QCOMPARE(change->subjectId(), renderTargetSelector->id());
-        QCOMPARE(change->value().value<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >(), QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>());
-        QCOMPARE(change->type(), Qt3DCore::PropertyUpdated);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
+
+        arbiter.dirtyNodes.clear();
     }
 
     void checkRenderTargetBookkeeping()
diff --git a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
index 4f6daae8c..648fbd5ce 100644
--- a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
+++ b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
@@ -159,14 +159,11 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeAddedChangePtr nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(nodeAddedChange->propertyName(), "parameter");
-        QCOMPARE(nodeAddedChange->subjectId(),techniqueFilter->id());
-        QCOMPARE(nodeAddedChange->addedNodeId(), param1->id());
-        QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded);
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
 
-        arbiter.events.clear();
 
         // WHEN
         techniqueFilter->addParameter(param1);
@@ -174,20 +171,17 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         techniqueFilter->removeParameter(param1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        Qt3DCore::QPropertyNodeRemovedChangePtr nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "parameter");
-        QCOMPARE(nodeRemovedChange->subjectId(), techniqueFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), param1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
@@ -195,14 +189,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        nodeAddedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(nodeAddedChange->propertyName(), "matchAll");
-        QCOMPARE(nodeAddedChange->subjectId(),techniqueFilter->id());
-        QCOMPARE(nodeAddedChange->addedNodeId(), filterKey1->id());
-        QCOMPARE(nodeAddedChange->type(), Qt3DCore::PropertyValueAdded);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
 
         // WHEN
         techniqueFilter->addMatch(filterKey1);
@@ -210,20 +200,17 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 0);
 
         // WHEN
         techniqueFilter->removeMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1);
-        nodeRemovedChange = arbiter.events.first().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(nodeRemovedChange->propertyName(), "matchAll");
-        QCOMPARE(nodeRemovedChange->subjectId(), techniqueFilter->id());
-        QCOMPARE(nodeRemovedChange->removedNodeId(), filterKey1->id());
-        QCOMPARE(nodeRemovedChange->type(), Qt3DCore::PropertyValueRemoved);
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
+        arbiter.dirtyNodes.clear();
     }
 
     void checkParameterBookkeeping()
diff --git a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
index bc4f2910e..e45ec704e 100644
--- a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
+++ b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
@@ -52,7 +52,6 @@
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
 #include <Qt3DRender/private/expandboundingvolumejob_p.h>
 #include <Qt3DRender/private/calcboundingvolumejob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/calcgeometrytrianglevolumes_p.h>
 #include <Qt3DRender/private/loadbufferjob_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
@@ -147,10 +146,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/rendercapture/tst_rendercapture.cpp b/tests/auto/render/rendercapture/tst_rendercapture.cpp
index 78b792b01..194c5cd24 100644
--- a/tests/auto/render/rendercapture/tst_rendercapture.cpp
+++ b/tests/auto/render/rendercapture/tst_rendercapture.cpp
@@ -49,7 +49,7 @@ private Q_SLOTS:
 
         // WHEN
         backend.setRenderer(&renderer);
-        simulateInitialization(&frontend, &backend);
+        simulateInitializationSync(&frontend, &backend);
 
         // THEN
         QVERIFY(!backend.peerId().isNull());
@@ -61,34 +61,33 @@ private Q_SLOTS:
     void checkEnabledPropertyChange()
     {
         // GIVEN
+        Qt3DRender::QRenderCapture frontend;
         Qt3DRender::Render::RenderCapture renderCapture;
         TestRenderer renderer;
         renderCapture.setRenderer(&renderer);
+        simulateInitializationSync(&frontend, &renderCapture);
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(renderCapture.peerId()));
-        change->setPropertyName(QByteArrayLiteral("enabled"));
-        change->setValue(QVariant::fromValue(true));
-        sceneChangeEvent(&renderCapture, change);
+        frontend.setEnabled(false);
+        renderCapture.syncFromFrontEnd(&frontend, false);
 
         // THEN
-        QCOMPARE(renderCapture.isEnabled(), true);
+        QCOMPARE(renderCapture.isEnabled(), false);
         QVERIFY(renderer.dirtyBits() & Qt3DRender::Render::AbstractRenderer::FrameGraphDirty);
     }
 
     void checkReceiveRenderCaptureRequest()
     {
         // GIVEN
+        Qt3DRender::QRenderCapture frontend;
         Qt3DRender::Render::RenderCapture renderCapture;
         TestRenderer renderer;
         renderCapture.setRenderer(&renderer);
-        renderCapture.setEnabled(true);
+        simulateInitializationSync(&frontend, &renderCapture);
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr change(new Qt3DCore::QPropertyUpdatedChange(renderCapture.peerId()));
-        change->setPropertyName(QByteArrayLiteral("renderCaptureRequest"));
-        change->setValue(QVariant::fromValue(32));
-        sceneChangeEvent(&renderCapture, change);
+        frontend.requestCapture();
+        renderCapture.syncFromFrontEnd(&frontend, false);
 
         // THEN
         QCOMPARE(renderCapture.wasCaptureRequested(), true);
diff --git a/tests/auto/render/renderer/tst_renderer.cpp b/tests/auto/render/renderer/tst_renderer.cpp
index a823c233a..973192d6a 100644
--- a/tests/auto/render/renderer/tst_renderer.cpp
+++ b/tests/auto/render/renderer/tst_renderer.cpp
@@ -315,30 +315,6 @@ private Q_SLOTS:
         renderQueue->reset();
 
         // WHEN
-        renderer.markDirty(Qt3DRender::Render::AbstractRenderer::EntityHierarchyDirty, nullptr);
-        jobs = renderer.renderBinJobs();
-
-        // THEN
-        QCOMPARE(jobs.size(),
-                 1 + // EntityEnabledDirty
-                 1 + // EntityHierarchyJob
-                 1 + // WorldTransformJob
-                 1 + // UpdateWorldBoundingVolume
-                 1 + // UpdateShaderDataTransform
-                 1 + // ExpandBoundingVolumeJob
-                 1 + // UpdateEntityLayersJob
-                 1 + // updateLevelOfDetailJob
-                 1 + // syncLoadingJobs
-                 1 + // updateSkinningPaletteJob
-                 1 + // cleanupJob
-                 1 + // sendBufferCaptureJob
-                 singleRenderViewJobCount +
-                 layerCacheJobCount);
-
-        renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
-        renderQueue->reset();
-
-        // WHEN
         renderer.markDirty(Qt3DRender::Render::AbstractRenderer::AllDirty, nullptr);
         jobs = renderer.renderBinJobs();
 
@@ -346,7 +322,6 @@ private Q_SLOTS:
         // and ShaderGathererJob are not added here)
         QCOMPARE(jobs.size(),
                  1 + // EntityEnabledDirty
-                 1 + // EntityHierarchyDirty
                  1 + // WorldTransformJob
                  1 + // UpdateWorldBoundingVolume
                  1 + // UpdateShaderDataTransform
diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp
index aef1c3657..f38915bf8 100644
--- a/tests/auto/render/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/renderviews/tst_renderviews.cpp
@@ -119,7 +119,7 @@ private Q_SLOTS:
 
             // WHEN
             frontendBarrier.setWaitOperations(barriers);
-            simulateInitialization(&frontendBarrier, &backendBarrier);
+            simulateInitializationSync(&frontendBarrier, &backendBarrier);
 
             // THEN
             QCOMPARE(renderView.memoryBarrier(), QMemoryBarrier::None);
diff --git a/tests/auto/render/setfence/tst_setfence.cpp b/tests/auto/render/setfence/tst_setfence.cpp
index b70bf548c..92f7a0acc 100644
--- a/tests/auto/render/setfence/tst_setfence.cpp
+++ b/tests/auto/render/setfence/tst_setfence.cpp
@@ -75,7 +75,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::SetFence backendSetFence;
             backendSetFence.setRenderer(&renderer);
-            simulateInitialization(&setFence, &backendSetFence);
+            simulateInitializationSync(&setFence, &backendSetFence);
 
             // THEN
             QCOMPARE(backendSetFence.isEnabled(), true);
@@ -88,7 +88,7 @@ private Q_SLOTS:
             Qt3DRender::Render::SetFence backendSetFence;
             setFence.setEnabled(false);
             backendSetFence.setRenderer(&renderer);
-            simulateInitialization(&setFence, &backendSetFence);
+            simulateInitializationSync(&setFence, &backendSetFence);
 
             // THEN
             QCOMPARE(backendSetFence.peerId(), setFence.id());
@@ -101,16 +101,16 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3DRender::Render::SetFence backendSetFence;
+        Qt3DRender::QSetFence setFence;
         TestRenderer renderer;
         backendSetFence.setRenderer(&renderer);
+        simulateInitializationSync(&setFence, &backendSetFence);
 
         {
              // WHEN
              const bool newValue = false;
-             const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-             change->setPropertyName("enabled");
-             change->setValue(newValue);
-             backendSetFence.sceneChangeEvent(change);
+             setFence.setEnabled(newValue);
+             backendSetFence.syncFromFrontEnd(&setFence, false);
 
              // THEN
             QCOMPARE(backendSetFence.isEnabled(), newValue);
diff --git a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
index d79b0b4f7..a4811d82c 100644
--- a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
+++ b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
@@ -70,7 +70,7 @@ private Q_SLOTS:
 
         // WHEN
         backendNode.setRenderer(&renderer);
-        simulateInitialization(&sortPolicy, &backendNode);
+        simulateInitializationSync(&sortPolicy, &backendNode);
 
         // THEN
         QCOMPARE(backendNode.peerId(), sortPolicy.id());
@@ -88,15 +88,14 @@ private Q_SLOTS:
         Qt3DRender::Render::SortPolicy backendNode;
         backendNode.setRenderer(&renderer);
 
+        Qt3DRender::QSortPolicy sortPolicy;
+        sortPolicy.setSortTypes(sortTypes);
+
+        simulateInitializationSync(&sortPolicy, &backendNode);
+
         // WHEN
-        auto sortTypeInts = QVector<int>();
-        std::transform(sortTypes.constBegin(), sortTypes.constEnd(),
-                       std::back_inserter(sortTypeInts),
-                       [] (Qt3DRender::QSortPolicy::SortType type) -> int { return type; });
-        Qt3DCore::QPropertyUpdatedChangePtr updateChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        updateChange->setValue(QVariant::fromValue(sortTypeInts));
-        updateChange->setPropertyName("sortTypes");
-        backendNode.sceneChangeEvent(updateChange);
+        sortPolicy.setSortTypes(sortTypes);
+        backendNode.syncFromFrontEnd(&sortPolicy, false);
 
         // THEN
         QCOMPARE(backendNode.sortTypes(), sortTypes);
diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
index 0d900a202..492aa0fde 100644
--- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
+++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
@@ -29,7 +29,6 @@
 #include <QtTest/QTest>
 #include <Qt3DRender/private/updateshaderdatatransformjob_p.h>
 #include <Qt3DRender/private/updateworldtransformjob_p.h>
-#include <Qt3DRender/private/updateentityhierarchyjob_p.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/managers_p.h>
 #include <Qt3DRender/qrenderaspect.h>
@@ -129,10 +128,6 @@ namespace {
 
 void runRequiredJobs(Qt3DRender::TestAspect *test)
 {
-    Qt3DRender::Render::UpdateEntityHierarchyJob updateEntitiesJob;
-    updateEntitiesJob.setManager(test->nodeManagers());
-    updateEntitiesJob.run();
-
     Qt3DRender::Render::UpdateWorldTransformJob updateWorldTransform;
     updateWorldTransform.setRoot(test->sceneRoot());
     updateWorldTransform.setManagers(test->nodeManagers());
diff --git a/tests/auto/render/waitfence/tst_waitfence.cpp b/tests/auto/render/waitfence/tst_waitfence.cpp
index e8cd4c30b..e27e4ae19 100644
--- a/tests/auto/render/waitfence/tst_waitfence.cpp
+++ b/tests/auto/render/waitfence/tst_waitfence.cpp
@@ -82,7 +82,7 @@ private Q_SLOTS:
             // WHEN
             Qt3DRender::Render::WaitFence backendWaitFence;
             backendWaitFence.setRenderer(&renderer);
-            simulateInitialization(&waitFence, &backendWaitFence);
+            simulateInitializationSync(&waitFence, &backendWaitFence);
 
             // THEN
             QCOMPARE(backendWaitFence.isEnabled(), true);
@@ -99,7 +99,7 @@ private Q_SLOTS:
             Qt3DRender::Render::WaitFence backendWaitFence;
             waitFence.setEnabled(false);
             backendWaitFence.setRenderer(&renderer);
-            simulateInitialization(&waitFence, &backendWaitFence);
+            simulateInitializationSync(&waitFence, &backendWaitFence);
 
             // THEN
             QCOMPARE(backendWaitFence.peerId(), waitFence.id());
@@ -115,17 +115,17 @@ private Q_SLOTS:
     void checkSceneChangeEvents()
     {
         // GIVEN
+        Qt3DRender::QWaitFence waitFence;
         Qt3DRender::Render::WaitFence backendWaitFence;
         TestRenderer renderer;
         backendWaitFence.setRenderer(&renderer);
+        simulateInitializationSync(&waitFence, &backendWaitFence);
 
         {
             // WHEN
             const bool newValue = false;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("enabled");
-            change->setValue(newValue);
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setEnabled(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.isEnabled(), newValue);
@@ -135,10 +135,8 @@ private Q_SLOTS:
         {
             // WHEN
             const QVariant newValue(984);
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("handle");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setHandle(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().handle, QVariant(984));
@@ -148,10 +146,8 @@ private Q_SLOTS:
         {
             // WHEN
             const Qt3DRender::QWaitFence::HandleType newValue = Qt3DRender::QWaitFence::OpenGLFenceId;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("handleType");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setHandleType(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().handleType, Qt3DRender::QWaitFence::OpenGLFenceId);
@@ -161,10 +157,8 @@ private Q_SLOTS:
         {
             // WHEN
             const bool newValue = true;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("waitOnCPU");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setWaitOnCPU(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().waitOnCPU, true);
@@ -174,10 +168,8 @@ private Q_SLOTS:
         {
             // WHEN
             const quint64 newValue = 984;
-            const auto change = Qt3DCore::QPropertyUpdatedChangePtr::create(Qt3DCore::QNodeId());
-            change->setPropertyName("timeout");
-            change->setValue(QVariant::fromValue(newValue));
-            backendWaitFence.sceneChangeEvent(change);
+            waitFence.setTimeout(newValue);
+            backendWaitFence.syncFromFrontEnd(&waitFence, false);
 
             // THEN
             QCOMPARE(backendWaitFence.data().timeout, quint64(984));