Remove deprecated classes and functions

Mostly old messaging API

Change-Id: I17eb2206b2ede56d2f7d36375d5e711d6149019f
Reviewed-by: Paul Lemire <paul.lemire@kdab.com>

153 files changed, 1460 insertions, 8649 deletions

diff --git a/tests/auto/animation/animationclip/tst_animationclip.cpp b/tests/auto/animation/animationclip/tst_animationclip.cpp
index d28a8fc58..3860e7726 100644
--- a/tests/auto/animation/animationclip/tst_animationclip.cpp
+++ b/tests/auto/animation/animationclip/tst_animationclip.cpp
@@ -33,7 +33,6 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
 
 using namespace Qt3DAnimation::Animation;
 
diff --git a/tests/auto/animation/animationutils/tst_animationutils.cpp b/tests/auto/animation/animationutils/tst_animationutils.cpp
index 05558192d..0ee455daf 100644
--- a/tests/auto/animation/animationutils/tst_animationutils.cpp
+++ b/tests/auto/animation/animationutils/tst_animationutils.cpp
@@ -46,7 +46,7 @@
 #include <QtCore/qbitarray.h>
 
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 using namespace Qt3DAnimation::Animation;
 
diff --git a/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp b/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
index fb741050b..6c99579c2 100644
--- a/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
+++ b/tests/auto/animation/blendedclipanimator/tst_blendedclipanimator.cpp
@@ -35,7 +35,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 #include <QtTest/QTest>
 #include <Qt3DAnimation/qblendedclipanimator.h>
diff --git a/tests/auto/animation/channelmapper/tst_channelmapper.cpp b/tests/auto/animation/channelmapper/tst_channelmapper.cpp
index ad9f3c423..8b75b0a52 100644
--- a/tests/auto/animation/channelmapper/tst_channelmapper.cpp
+++ b/tests/auto/animation/channelmapper/tst_channelmapper.cpp
@@ -38,7 +38,7 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_ChannelMapper : public Qt3DCore::QBackendNodeTester
 {
diff --git a/tests/auto/animation/channelmapping/tst_channelmapping.cpp b/tests/auto/animation/channelmapping/tst_channelmapping.cpp
index 26a57449d..9bee116d4 100644
--- a/tests/auto/animation/channelmapping/tst_channelmapping.cpp
+++ b/tests/auto/animation/channelmapping/tst_channelmapping.cpp
@@ -39,7 +39,7 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_TargetEntity : public Qt3DCore::QEntity
 {
diff --git a/tests/auto/animation/clipanimator/tst_clipanimator.cpp b/tests/auto/animation/clipanimator/tst_clipanimator.cpp
index 5eccb0432..ce39f6469 100644
--- a/tests/auto/animation/clipanimator/tst_clipanimator.cpp
+++ b/tests/auto/animation/clipanimator/tst_clipanimator.cpp
@@ -36,7 +36,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_ClipAnimator: public Qt3DCore::QBackendNodeTester
 {
diff --git a/tests/auto/animation/clipblendnode/tst_clipblendnode.cpp b/tests/auto/animation/clipblendnode/tst_clipblendnode.cpp
index c8649a692..62d57206d 100644
--- a/tests/auto/animation/clipblendnode/tst_clipblendnode.cpp
+++ b/tests/auto/animation/clipblendnode/tst_clipblendnode.cpp
@@ -131,7 +131,7 @@ private Q_SLOTS:
             ClipBlendNodeManager manager;
             TestClipBlendNode backendClipBlendNode;
             backendClipBlendNode.setClipBlendNodeManager(&manager);
-            simulateInitialization(&clipBlendNode, &backendClipBlendNode);
+            simulateInitializationSync(&clipBlendNode, &backendClipBlendNode);
 
             // THEN
             QCOMPARE(backendClipBlendNode.isEnabled(), true);
@@ -146,7 +146,7 @@ private Q_SLOTS:
             TestClipBlendNode backendClipBlendNode;
             clipBlendNode.setEnabled(false);
             backendClipBlendNode.setClipBlendNodeManager(&manager);
-            simulateInitialization(&clipBlendNode, &backendClipBlendNode);
+            simulateInitializationSync(&clipBlendNode, &backendClipBlendNode);
 
             // THEN
             QCOMPARE(backendClipBlendNode.peerId(), clipBlendNode.id());
diff --git a/tests/auto/animation/clock/tst_clock.cpp b/tests/auto/animation/clock/tst_clock.cpp
index 03be85613..4cc397661 100644
--- a/tests/auto/animation/clock/tst_clock.cpp
+++ b/tests/auto/animation/clock/tst_clock.cpp
@@ -33,7 +33,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_Clock: public Qt3DCore::QBackendNodeTester
 {
diff --git a/tests/auto/animation/findrunningclipanimatorsjob/tst_findrunningclipanimatorsjob.cpp b/tests/auto/animation/findrunningclipanimatorsjob/tst_findrunningclipanimatorsjob.cpp
index baebf8e46..bfcaae776 100644
--- a/tests/auto/animation/findrunningclipanimatorsjob/tst_findrunningclipanimatorsjob.cpp
+++ b/tests/auto/animation/findrunningclipanimatorsjob/tst_findrunningclipanimatorsjob.cpp
@@ -41,7 +41,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 using namespace Qt3DAnimation::Animation;
 
diff --git a/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp b/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp
index 41f6b268a..edf147d88 100644
--- a/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp
+++ b/tests/auto/animation/qadditiveclipblend/tst_qadditiveclipblend.cpp
@@ -33,10 +33,7 @@
 #include <Qt3DAnimation/private/qadditiveclipblend_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DAnimation/qclipblendnodecreatedchange.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QAdditiveClipBlend : public QObject
 {
@@ -125,97 +122,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QAdditiveClipBlend addBlend;
-        Qt3DAnimation::QAdditiveClipBlend baseClip;
-        Qt3DAnimation::QAdditiveClipBlend additiveClip;
-
-        addBlend.setBaseClip(&baseClip);
-        addBlend.setAdditiveClip(&additiveClip);
-        addBlend.setAdditiveFactor(0.8f);
-
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&addBlend);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // 1 + 2 clips
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QAdditiveClipBlendData>>(creationChanges.first());
-            const Qt3DAnimation::QAdditiveClipBlendData cloneData = creationChangeData->data;
-
-            QCOMPARE(addBlend.additiveFactor(), cloneData.additiveFactor);
-            QCOMPARE(addBlend.id(), creationChangeData->subjectId());
-            QCOMPARE(addBlend.isEnabled(), true);
-            QCOMPARE(addBlend.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(addBlend.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.baseClipId, baseClip.id());
-            QCOMPARE(cloneData.additiveClipId, additiveClip.id());
-        }
-
-        // WHEN
-        addBlend.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&addBlend);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // 1 + 2 clips
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QAdditiveClipBlendData>>(creationChanges.first());
-            const Qt3DAnimation::QAdditiveClipBlendData cloneData = creationChangeData->data;
-
-            QCOMPARE(addBlend.additiveFactor(), cloneData.additiveFactor);
-            QCOMPARE(addBlend.id(), creationChangeData->subjectId());
-            QCOMPARE(addBlend.isEnabled(), false);
-            QCOMPARE(addBlend.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(addBlend.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.baseClipId, baseClip.id());
-            QCOMPARE(cloneData.additiveClipId, additiveClip.id());
-        }
-    }
-
-    void checkAdditiveFactorUpdate()
-    {
-        // GIVEN
-        TestArbiter arbiter;
-        Qt3DAnimation::QAdditiveClipBlend addBlend;
-        arbiter.setArbiterOnNode(&addBlend);
-
-        {
-            // WHEN
-            addBlend.setAdditiveFactor(0.4f);
-
-            // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &addBlend);
-
-            arbiter.dirtyNodes.clear();
-        }
-
-        {
-            // WHEN
-            addBlend.setAdditiveFactor(0.4f);
-
-            // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
-        }
-
-    }
-
     void checkBaseClipUpdate()
     {
         // GIVEN
@@ -229,11 +135,10 @@ private Q_SLOTS:
             addBlend.setBaseClip(baseClip);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &addBlend);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &addBlend);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -241,8 +146,7 @@ private Q_SLOTS:
             addBlend.setBaseClip(baseClip);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -259,19 +163,16 @@ private Q_SLOTS:
             addBlend.setAdditiveClip(additiveClip);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &addBlend);
-            arbiter.dirtyNodes.clear();
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &addBlend);
+            arbiter.clear();
         }
 
         {
             // WHEN
             addBlend.setAdditiveClip(additiveClip);
 
-            //
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
diff --git a/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp b/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
index 00130add3..140235505 100644
--- a/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
+++ b/tests/auto/animation/qanimationcliploader/tst_qanimationcliploader.cpp
@@ -30,11 +30,9 @@
 #include <QtTest/QTest>
 #include <Qt3DAnimation/qanimationcliploader.h>
 #include <Qt3DAnimation/private/qanimationcliploader_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_QAnimationClipLoader : public Qt3DAnimation::QAnimationClipLoader
 {
@@ -78,56 +76,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QAnimationClipLoader clip;
-
-        clip.setSource(QUrl(QStringLiteral("http://someRemoteURL.com")));
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&clip);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QAnimationClipLoaderData>>(creationChanges.first());
-            const Qt3DAnimation::QAnimationClipLoaderData data = creationChangeData->data;
-
-            QCOMPARE(clip.id(), creationChangeData->subjectId());
-            QCOMPARE(clip.isEnabled(), true);
-            QCOMPARE(clip.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(clip.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(clip.source(), data.source);
-        }
-
-        // WHEN
-        clip.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&clip);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QAnimationClipLoaderData>>(creationChanges.first());
-
-            QCOMPARE(clip.id(), creationChangeData->subjectId());
-            QCOMPARE(clip.isEnabled(), false);
-            QCOMPARE(clip.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(clip.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkSourceUpdate()
     {
         // GIVEN
@@ -140,11 +88,10 @@ private Q_SLOTS:
             clip.setSource(QUrl(QStringLiteral("qrc:/toyplane.qlip")));
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &clip);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &clip);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -152,8 +99,7 @@ private Q_SLOTS:
             clip.setSource(QStringLiteral("qrc:/toyplane.qlip"));
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp b/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp
index 81222292f..9aed1bf15 100644
--- a/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp
+++ b/tests/auto/animation/qblendedclipanimator/tst_qblendedclipanimator.cpp
@@ -32,11 +32,9 @@
 #include <Qt3DAnimation/private/qblendedclipanimator_p.h>
 #include <Qt3DAnimation/qlerpclipblend.h>
 #include <Qt3DAnimation/qchannelmapper.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_QBlendedClipAnimator : public QObject
 {
@@ -187,68 +185,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QBlendedClipAnimator blendedClipAnimator;
-        Qt3DAnimation::QChannelMapper channelMapper;
-        Qt3DAnimation::QLerpClipBlend blendRoot;
-
-        blendedClipAnimator.setBlendTree(&blendRoot);
-        blendedClipAnimator.setChannelMapper(&channelMapper);
-        blendedClipAnimator.setRunning(true);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&blendedClipAnimator);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // 1 + mapper + blend tree root
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QBlendedClipAnimatorData>>(creationChanges.first());
-            const Qt3DAnimation::QBlendedClipAnimatorData cloneData = creationChangeData->data;
-
-            QCOMPARE(blendedClipAnimator.blendTree()->id(), cloneData.blendTreeRootId);
-            QCOMPARE(blendedClipAnimator.channelMapper()->id(), cloneData.mapperId);
-            QCOMPARE(blendedClipAnimator.isRunning(), cloneData.running);
-            QCOMPARE(blendedClipAnimator.id(), creationChangeData->subjectId());
-            QCOMPARE(blendedClipAnimator.isEnabled(), true);
-            QCOMPARE(blendedClipAnimator.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(blendedClipAnimator.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(blendedClipAnimator.loopCount(), cloneData.loops);
-            QCOMPARE(blendedClipAnimator.normalizedTime(), cloneData.normalizedTime);
-        }
-
-        // WHEN
-        blendedClipAnimator.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&blendedClipAnimator);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // 1 + mapper + blend tree root
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QBlendedClipAnimatorData>>(creationChanges.first());
-            const Qt3DAnimation::QBlendedClipAnimatorData cloneData = creationChangeData->data;
-
-            QCOMPARE(blendedClipAnimator.blendTree()->id(), cloneData.blendTreeRootId);
-            QCOMPARE(blendedClipAnimator.channelMapper()->id(), cloneData.mapperId);
-            QCOMPARE(blendedClipAnimator.isRunning(), cloneData.running);
-            QCOMPARE(blendedClipAnimator.id(), creationChangeData->subjectId());
-            QCOMPARE(blendedClipAnimator.isEnabled(), false);
-            QCOMPARE(blendedClipAnimator.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(blendedClipAnimator.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkBlendTreeUpdate()
     {
         // GIVEN
@@ -262,11 +198,10 @@ private Q_SLOTS:
             blendedClipAnimator.setBlendTree(&blendRoot);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &blendedClipAnimator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -274,8 +209,7 @@ private Q_SLOTS:
             blendedClipAnimator.setBlendTree(&blendRoot);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -310,11 +244,10 @@ private Q_SLOTS:
             blendedClipAnimator.setChannelMapper(&channelMapper);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &blendedClipAnimator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -322,8 +255,7 @@ private Q_SLOTS:
             blendedClipAnimator.setChannelMapper(&channelMapper);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -357,11 +289,10 @@ private Q_SLOTS:
             blendedClipAnimator.setRunning(true);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &blendedClipAnimator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -369,8 +300,7 @@ private Q_SLOTS:
             blendedClipAnimator.setRunning(true);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -387,11 +317,10 @@ private Q_SLOTS:
             blendedClipAnimator.setLoopCount(1584);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &blendedClipAnimator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -399,8 +328,7 @@ private Q_SLOTS:
             blendedClipAnimator.setLoopCount(1584);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -417,11 +345,10 @@ private Q_SLOTS:
             blendedClipAnimator.setNormalizedTime(0.5f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &blendedClipAnimator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &blendedClipAnimator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -429,8 +356,7 @@ private Q_SLOTS:
             blendedClipAnimator.setNormalizedTime(0.5f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
index fe1a2eda8..5037937a1 100644
--- a/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
+++ b/tests/auto/animation/qcallbackmapping/tst_qcallbackmapping.cpp
@@ -29,13 +29,10 @@
 #include <QtTest/QTest>
 #include <Qt3DAnimation/qcallbackmapping.h>
 #include <Qt3DAnimation/private/qcallbackmapping_p.h>
-#include <Qt3DAnimation/private/qchannelmappingcreatedchange_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class DummyCallback : public Qt3DAnimation::QAnimationCallback
 {
@@ -93,66 +90,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QCallbackMapping mapping;
-        auto callback = new DummyCallback();
-
-        mapping.setChannelName(QStringLiteral("Location"));
-        mapping.setCallback(QVariant::Vector3D, callback);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mapping);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QChannelMappingCreatedChange<Qt3DAnimation::QCallbackMappingData>>(creationChanges.first());
-            const Qt3DAnimation::QCallbackMappingData data = creationChangeData->data;
-
-            QCOMPARE(mapping.id(), creationChangeData->subjectId());
-            QCOMPARE(mapping.isEnabled(), true);
-            QCOMPARE(mapping.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mapping.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(creationChangeData->type(), Qt3DAnimation::QChannelMappingCreatedChangeBase::CallbackMapping);
-            QCOMPARE(mapping.channelName(), data.channelName);
-            QCOMPARE(mapping.callback(), data.callback);
-            QCOMPARE(int(QVariant::Vector3D), data.type);
-        }
-
-        // WHEN
-        mapping.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mapping);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QChannelMappingCreatedChange<Qt3DAnimation::QCallbackMappingData>>(creationChanges.first());
-            const Qt3DAnimation::QCallbackMappingData data = creationChangeData->data;
-
-            QCOMPARE(mapping.id(), creationChangeData->subjectId());
-            QCOMPARE(mapping.isEnabled(), false);
-            QCOMPARE(mapping.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mapping.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(creationChangeData->type(), Qt3DAnimation::QChannelMappingCreatedChangeBase::CallbackMapping);
-            QCOMPARE(mapping.channelName(), data.channelName);
-            QCOMPARE(mapping.callback(), data.callback);
-            QCOMPARE(QVariant::Vector3D, data.type);
-        }
-    }
-
     void checkPropertyUpdateChanges()
     {
         // GIVEN
@@ -165,16 +102,16 @@ private Q_SLOTS:
             mapping.setChannelName(QStringLiteral("Scale"));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mapping);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             mapping.setChannelName(QStringLiteral("Scale"));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -184,19 +121,17 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mapping);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             mapping.setCallback(QVariant::Vector3D, callback, Qt3DAnimation::QAnimationCallback::OnThreadPool);
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 };
diff --git a/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp b/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp
index a55a509b2..45c9c0f04 100644
--- a/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp
+++ b/tests/auto/animation/qchannelmapper/tst_qchannelmapper.cpp
@@ -29,13 +29,12 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DAnimation/qchannelmapper.h>
 #include <Qt3DAnimation/private/qchannelmapper_p.h>
 #include <Qt3DAnimation/qchannelmapping.h>
 
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_QChannelmapper : public Qt3DAnimation::QChannelMapper
 {
@@ -47,47 +46,6 @@ public:
     }
 
 private Q_SLOTS:
-    void checkCreationChange_data()
-    {
-        QTest::addColumn<Qt3DAnimation::QChannelMapper *>("mapper");
-
-        Qt3DAnimation::QChannelMapper *defaultConstructed = new Qt3DAnimation::QChannelMapper;
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DAnimation::QChannelMapper *mapperWithMappings = new Qt3DAnimation::QChannelMapper;
-        mapperWithMappings->addMapping(new Qt3DAnimation::QChannelMapping);
-        mapperWithMappings->addMapping(new Qt3DAnimation::QChannelMapping);
-        mapperWithMappings->addMapping(new Qt3DAnimation::QChannelMapping);
-        QTest::newRow("mapperWithMappings") << mapperWithMappings;
-    }
-
-    void checkCreationChange()
-    {
-        // GIVEN
-        QFETCH(Qt3DAnimation::QChannelMapper *, mapper);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(mapper);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        const int mappingCount = mapper->mappings().count();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + mappingCount);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DAnimation::QChannelMapperData> creationChange =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QChannelMapperData>>(creationChanges.first());
-        const Qt3DAnimation::QChannelMapperData &creationData = creationChange->data;
-
-        // THEN
-        QCOMPARE(mapper->id(), creationChange->subjectId());
-        QCOMPARE(mapper->isEnabled(), creationChange->isNodeEnabled());
-        QCOMPARE(mapper->metaObject(), creationChange->metaObject());
-        QCOMPARE(mappingCount, creationData.mappingIds.count());
-
-        for (int i = 0; i < mappingCount; ++i)
-            QCOMPARE(mapper->mappings().at(i)->id(), creationData.mappingIds.at(i));
-    }
 
     void checkPropertyUpdates()
     {
@@ -100,10 +58,10 @@ private Q_SLOTS:
         mapper->setEnabled(false);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), mapper.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), mapper.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkMappingBookkeeping()
diff --git a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
index 749bc5ec7..714fbdd90 100644
--- a/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
+++ b/tests/auto/animation/qchannelmapping/tst_qchannelmapping.cpp
@@ -30,14 +30,11 @@
 #include <Qt3DAnimation/qchannelmapping.h>
 #include <Qt3DAnimation/private/qabstractchannelmapping_p.h>
 #include <Qt3DAnimation/private/qchannelmapping_p.h>
-#include <Qt3DAnimation/private/qchannelmappingcreatedchange_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
 #include <QQuaternion>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_QTargetEntity : public Qt3DCore::QEntity
 {
@@ -169,71 +166,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QChannelMapping mapping;
-        auto target = new tst_QTargetEntity;
-
-        mapping.setChannelName(QStringLiteral("Location"));
-        mapping.setTarget(target);
-        mapping.setProperty(QStringLiteral("translation"));
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mapping);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // 1 for mapping, 1 for target
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QChannelMappingCreatedChange<Qt3DAnimation::QChannelMappingData>>(creationChanges.first());
-            const Qt3DAnimation::QChannelMappingData data = creationChangeData->data;
-
-            QCOMPARE(mapping.id(), creationChangeData->subjectId());
-            QCOMPARE(mapping.isEnabled(), true);
-            QCOMPARE(mapping.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mapping.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(creationChangeData->type(), Qt3DAnimation::QChannelMappingCreatedChangeBase::ChannelMapping);
-            QCOMPARE(mapping.channelName(), data.channelName);
-            QCOMPARE(mapping.target()->id(), data.targetId);
-            QVERIFY(qstrcmp(mapping.property().toLatin1().constData(), data.propertyName) == 0);
-            QCOMPARE(data.type, static_cast<int>(QVariant::Vector3D));
-            QCOMPARE(data.componentCount, 3);
-        }
-
-        // WHEN
-        mapping.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mapping);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // 1 for mapping, 1 for target
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QChannelMappingCreatedChange<Qt3DAnimation::QChannelMappingData>>(creationChanges.first());
-            const Qt3DAnimation::QChannelMappingData data = creationChangeData->data;
-
-            QCOMPARE(mapping.id(), creationChangeData->subjectId());
-            QCOMPARE(mapping.isEnabled(), false);
-            QCOMPARE(mapping.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mapping.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(creationChangeData->type(), Qt3DAnimation::QChannelMappingCreatedChangeBase::ChannelMapping);
-            QCOMPARE(mapping.channelName(), data.channelName);
-            QCOMPARE(mapping.target()->id(), data.targetId);
-            QVERIFY(qstrcmp(mapping.property().toLatin1().constData(), data.propertyName) == 0);
-            QCOMPARE(data.type, static_cast<int>(QVariant::Vector3D));
-            QCOMPARE(data.componentCount, 3);
-        }
-    }
-
     void checkPropertyUpdateChanges()
     {
         // GIVEN
@@ -247,16 +179,16 @@ private Q_SLOTS:
             mapping.setChannelName(QStringLiteral("Scale"));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mapping);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             mapping.setChannelName(QStringLiteral("Scale"));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -264,16 +196,16 @@ private Q_SLOTS:
             mapping.setTarget(target.data());
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mapping);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             mapping.setTarget(target.data());
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -283,19 +215,17 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mapping);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             mapping.setProperty(QStringLiteral("scale"));
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -341,16 +271,16 @@ private Q_SLOTS:
             target->setProperty(propertyName.constData(), value);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), target.data());
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), target.data());
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // THEN
             mapping.setProperty(QString::fromLatin1(propertyName));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
         }
     }
 
diff --git a/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp b/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp
index 174cd6bce..34544d04b 100644
--- a/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp
+++ b/tests/auto/animation/qclipanimator/tst_qclipanimator.cpp
@@ -34,11 +34,9 @@
 #include <Qt3DAnimation/qclipanimator.h>
 #include <Qt3DAnimation/private/qanimationclip_p.h>
 #include <Qt3DAnimation/private/qclipanimator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_QClipAnimator : public QObject
 {
@@ -181,61 +179,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QClipAnimator animator;
-        auto clip = new Qt3DAnimation::QAnimationClipLoader();
-        animator.setClip(clip);
-        auto mapper = new Qt3DAnimation::QChannelMapper();
-        animator.setChannelMapper(mapper);
-        auto clock = new Qt3DAnimation::QClock();
-        animator.setClock(clock);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&animator);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 4);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QClipAnimatorData>>(creationChanges.first());
-            const Qt3DAnimation::QClipAnimatorData data = creationChangeData->data;
-
-            QCOMPARE(animator.id(), creationChangeData->subjectId());
-            QCOMPARE(animator.isEnabled(), true);
-            QCOMPARE(animator.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(animator.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(animator.clip()->id(), data.clipId);
-            QCOMPARE(animator.channelMapper()->id(), data.mapperId);
-            QCOMPARE(animator.clock()->id(), data.clockId);
-            QCOMPARE(animator.loopCount(), data.loops);
-        }
-
-        // WHEN
-        animator.setEnabled(false);
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&animator);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 4);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QClipAnimatorData>>(creationChanges.first());
-
-            QCOMPARE(animator.id(), creationChangeData->subjectId());
-            QCOMPARE(animator.isEnabled(), false);
-            QCOMPARE(animator.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(animator.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkPropertyUpdate()
     {
         // GIVEN
@@ -249,10 +192,10 @@ private Q_SLOTS:
             animator.setClip(clip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &animator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -260,7 +203,7 @@ private Q_SLOTS:
             animator.setClip(clip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         // GIVEN
@@ -270,10 +213,10 @@ private Q_SLOTS:
             animator.setChannelMapper(mapper);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &animator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -281,7 +224,7 @@ private Q_SLOTS:
             animator.setChannelMapper(mapper);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         // GIVEN
@@ -291,10 +234,10 @@ private Q_SLOTS:
             animator.setClock(clock);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &animator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -302,7 +245,7 @@ private Q_SLOTS:
             animator.setClock(clock);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -310,10 +253,10 @@ private Q_SLOTS:
             animator.setLoopCount(10);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &animator);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &animator);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -321,7 +264,7 @@ private Q_SLOTS:
             animator.setLoopCount(10);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp b/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp
index b7e4f453b..d34ee0d31 100644
--- a/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp
+++ b/tests/auto/animation/qclipblendvalue/tst_qclipblendvalue.cpp
@@ -33,10 +33,7 @@
 #include <Qt3DAnimation/private/qclipblendvalue_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DAnimation/qclipblendnodecreatedchange.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_QClipBlendValue : public QObject
 {
@@ -83,59 +80,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QClipBlendValue clipBlendNode;
-        Qt3DAnimation::QAnimationClipLoader clip;
-
-        clipBlendNode.setClip(&clip);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&clipBlendNode);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // 1 + 1 clip
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QClipBlendValueData>>(creationChanges.first());
-            const Qt3DAnimation::QClipBlendValueData cloneData = creationChangeData->data;
-
-            QCOMPARE(clipBlendNode.id(), creationChangeData->subjectId());
-            QCOMPARE(clipBlendNode.isEnabled(), true);
-            QCOMPARE(clipBlendNode.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(clipBlendNode.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.clipId, clip.id());
-        }
-
-        // WHEN
-        clipBlendNode.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&clipBlendNode);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // 1 + 1 clip
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QClipBlendValueData>>(creationChanges.first());
-            const Qt3DAnimation::QClipBlendValueData cloneData = creationChangeData->data;
-
-            QCOMPARE(clipBlendNode.id(), creationChangeData->subjectId());
-            QCOMPARE(clipBlendNode.isEnabled(), false);
-            QCOMPARE(clipBlendNode.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(clipBlendNode.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.clipId, clip.id());
-        }
-    }
-
     void checkClipUpdate()
     {
         // GIVEN
@@ -149,10 +93,10 @@ private Q_SLOTS:
             clipBlendNode.setClip(clip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &clipBlendNode);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &clipBlendNode);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -160,7 +104,7 @@ private Q_SLOTS:
             clipBlendNode.setClip(clip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
diff --git a/tests/auto/animation/qclock/tst_qclock.cpp b/tests/auto/animation/qclock/tst_qclock.cpp
index 65c485566..04e479774 100644
--- a/tests/auto/animation/qclock/tst_qclock.cpp
+++ b/tests/auto/animation/qclock/tst_qclock.cpp
@@ -30,11 +30,9 @@
 #include <QtTest/QTest>
 #include <Qt3DAnimation/qclock.h>
 #include <Qt3DAnimation/private/qclock_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_QClock : public QObject
 {
@@ -79,53 +77,6 @@ private Q_SLOTS:
         QCOMPARE(spy.count(), 0);
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QClock clock;
-        clock.setPlaybackRate(10.f);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&clock);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QClockData>>(creationChanges.first());
-            const Qt3DAnimation::QClockData data = creationChangeData->data;
-
-            QCOMPARE(clock.id(), creationChangeData->subjectId());
-            QCOMPARE(clock.isEnabled(), true);
-            QCOMPARE(clock.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(clock.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(clock.playbackRate(), data.playbackRate);
-        }
-
-        // WHEN
-        clock.setEnabled(false);
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&clock);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DAnimation::QClockData>>(creationChanges.first());
-
-            QCOMPARE(clock.id(), creationChangeData->subjectId());
-            QCOMPARE(clock.isEnabled(), false);
-            QCOMPARE(clock.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(clock.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkPropertyUpdate()
     {
         // GIVEN
@@ -138,10 +89,10 @@ private Q_SLOTS:
             clock.setPlaybackRate(10.5f);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &clock);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &clock);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -149,7 +100,7 @@ private Q_SLOTS:
             clock.setPlaybackRate(10.5f);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 };
diff --git a/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp b/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp
index 68970838c..11d094596 100644
--- a/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp
+++ b/tests/auto/animation/qlerpclipblend/tst_qlerpclipblend.cpp
@@ -33,10 +33,7 @@
 #include <Qt3DAnimation/private/qlerpclipblend_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DAnimation/qclipblendnodecreatedchange.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QLerpClipBlend : public QObject
 {
@@ -125,67 +122,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QLerpClipBlend lerpBlend;
-        Qt3DAnimation::QLerpClipBlend startClip;
-        Qt3DAnimation::QLerpClipBlend endClip;
-
-        lerpBlend.setStartClip(&startClip);
-        lerpBlend.setEndClip(&endClip);
-        lerpBlend.setBlendFactor(0.8f);
-
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&lerpBlend);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // 1 + 2 clips
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QLerpClipBlendData>>(creationChanges.first());
-            const Qt3DAnimation::QLerpClipBlendData cloneData = creationChangeData->data;
-
-            QCOMPARE(lerpBlend.blendFactor(), cloneData.blendFactor);
-            QCOMPARE(lerpBlend.id(), creationChangeData->subjectId());
-            QCOMPARE(lerpBlend.isEnabled(), true);
-            QCOMPARE(lerpBlend.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(lerpBlend.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.startClipId, startClip.id());
-            QCOMPARE(cloneData.endClipId, endClip.id());
-        }
-
-        // WHEN
-        lerpBlend.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&lerpBlend);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // 1 + 2 clips
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QClipBlendNodeCreatedChange<Qt3DAnimation::QLerpClipBlendData>>(creationChanges.first());
-            const Qt3DAnimation::QLerpClipBlendData cloneData = creationChangeData->data;
-
-            QCOMPARE(lerpBlend.blendFactor(), cloneData.blendFactor);
-            QCOMPARE(lerpBlend.id(), creationChangeData->subjectId());
-            QCOMPARE(lerpBlend.isEnabled(), false);
-            QCOMPARE(lerpBlend.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(lerpBlend.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.startClipId, startClip.id());
-            QCOMPARE(cloneData.endClipId, endClip.id());
-        }
-    }
-
     void checkBlendFactorUpdate()
     {
         // GIVEN
@@ -198,10 +134,10 @@ private Q_SLOTS:
             lerpBlend.setBlendFactor(0.4f);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &lerpBlend);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &lerpBlend);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -209,7 +145,7 @@ private Q_SLOTS:
             lerpBlend.setBlendFactor(0.4f);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -227,10 +163,10 @@ private Q_SLOTS:
             lerpBlend.setStartClip(startClip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &lerpBlend);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &lerpBlend);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -238,7 +174,7 @@ private Q_SLOTS:
             lerpBlend.setStartClip(startClip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -255,10 +191,10 @@ private Q_SLOTS:
             lerpBlend.setEndClip(endClip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &lerpBlend);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &lerpBlend);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -266,7 +202,7 @@ private Q_SLOTS:
             lerpBlend.setEndClip(endClip);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
diff --git a/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp b/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp
index 1eff6a568..b1d0928d8 100644
--- a/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp
+++ b/tests/auto/animation/qskeletonmapping/tst_qskeletonmapping.cpp
@@ -31,11 +31,9 @@
 #include <Qt3DAnimation/private/qskeletonmapping_p.h>
 #include <Qt3DCore/qskeleton.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 class tst_QSkeletonMapping : public QObject
 {
@@ -82,61 +80,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DAnimation::QSkeletonMapping mapping;
-        auto target = new Qt3DCore::QSkeleton;
-
-        mapping.setSkeleton(target);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mapping);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // 1 for mapping, 1 for skeleton
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QChannelMappingCreatedChange<Qt3DAnimation::QSkeletonMappingData>>(creationChanges.first());
-            const Qt3DAnimation::QSkeletonMappingData data = creationChangeData->data;
-
-            QCOMPARE(mapping.id(), creationChangeData->subjectId());
-            QCOMPARE(mapping.isEnabled(), true);
-            QCOMPARE(mapping.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mapping.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(creationChangeData->type(), Qt3DAnimation::QChannelMappingCreatedChangeBase::SkeletonMapping);
-            QCOMPARE(mapping.skeleton()->id(), data.skeletonId);
-        }
-
-        // WHEN
-        mapping.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mapping);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // 1 for mapping, 1 for skeleton
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DAnimation::QChannelMappingCreatedChange<Qt3DAnimation::QSkeletonMappingData>>(creationChanges.first());
-            const Qt3DAnimation::QSkeletonMappingData data = creationChangeData->data;
-
-            QCOMPARE(mapping.id(), creationChangeData->subjectId());
-            QCOMPARE(mapping.isEnabled(), false);
-            QCOMPARE(mapping.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mapping.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(creationChangeData->type(), Qt3DAnimation::QChannelMappingCreatedChangeBase::SkeletonMapping);
-            QCOMPARE(mapping.skeleton()->id(), data.skeletonId);
-        }
-    }
-
     void checkPropertyUpdateChanges()
     {
         // GIVEN
@@ -150,16 +93,16 @@ private Q_SLOTS:
             mapping.setSkeleton(target);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mapping);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mapping);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             mapping.setSkeleton(target);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 };
diff --git a/tests/auto/animation/skeleton/tst_skeleton.cpp b/tests/auto/animation/skeleton/tst_skeleton.cpp
index d9b209194..3b4b0a429 100644
--- a/tests/auto/animation/skeleton/tst_skeleton.cpp
+++ b/tests/auto/animation/skeleton/tst_skeleton.cpp
@@ -34,7 +34,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 using namespace Qt3DCore;
 using namespace Qt3DAnimation;
diff --git a/tests/auto/core/common/common.pri b/tests/auto/core/common/common.pri
index 9b761b8e0..53d2b1ac2 100644
--- a/tests/auto/core/common/common.pri
+++ b/tests/auto/core/common/common.pri
@@ -1,9 +1,3 @@
-SOURCES += \
-    $$PWD/testpostmanarbiter.cpp
-
-HEADERS += \
-    $$PWD/testpostmanarbiter.h
-
 INCLUDEPATH += $$PWD
 
 qtConfig(private_tests) {
@@ -11,7 +5,8 @@ qtConfig(private_tests) {
         $$PWD/qbackendnodetester.cpp
 
     HEADERS += \
-        $$PWD/qbackendnodetester.h
+        $$PWD/qbackendnodetester.h \
+        $$PWD/testarbiter.h
 }
 
 QT += core-private 3dcore 3dcore-private
diff --git a/tests/auto/core/common/qbackendnodetester.cpp b/tests/auto/core/common/qbackendnodetester.cpp
index 13f4683d9..64bf21590 100644
--- a/tests/auto/core/common/qbackendnodetester.cpp
+++ b/tests/auto/core/common/qbackendnodetester.cpp
@@ -52,35 +52,6 @@ void QBackendNodeTester::setPeerId(QBackendNode *backend, QNodeId id)
     backend->setPeerId(id);
 }
 
-void QBackendNodeTester::simulateInitialization(QNode *frontend, QBackendNode *backend)
-{
-    Q_ASSERT(frontend);
-    Q_ASSERT(backend);
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_DEPRECATED
-    const auto change = frontend->createNodeCreationChange();
-    backend->setPeerId(change->subjectId());
-    backend->setEnabled(change->isNodeEnabled());
-    backend->initializeFromPeer(change);
-    QT_WARNING_POP
-}
-
-void QBackendNodeTester::sceneChangeEvent(QBackendNode *backend, const Qt3DCore::QSceneChangePtr &e)
-{
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_DEPRECATED
-    backend->sceneChangeEvent(e);
-    QT_WARNING_POP
-}
-
-QNodeCreatedChangeBasePtr QBackendNodeTester::creationChange(QNode *frontend) const
-{
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_DEPRECATED
-    return frontend->createNodeCreationChange();
-    QT_WARNING_POP
-}
-
 } // namespace Qt3DCore
 
 QT_END_NAMESPACE
diff --git a/tests/auto/core/common/qbackendnodetester.h b/tests/auto/core/common/qbackendnodetester.h
index a0b89e503..c0f8481df 100644
--- a/tests/auto/core/common/qbackendnodetester.h
+++ b/tests/auto/core/common/qbackendnodetester.h
@@ -39,8 +39,6 @@
 
 #include <QObject>
 #include <Qt3DCore/qnodeid.h>
-#include <Qt3DCore/qscenechange.h>
-#include <Qt3DCore/qnodecreatedchange.h>
 #include <Qt3DCore/qnode.h>
 
 QT_BEGIN_NAMESPACE
@@ -57,8 +55,6 @@ public:
 
     // Proxies to allow test classes to call private methods on QBackendNode
     void setPeerId(QBackendNode *backend, QNodeId id);
-    void sceneChangeEvent(QBackendNode *backend, const Qt3DCore::QSceneChangePtr &e);
-    Qt3DCore::QNodeCreatedChangeBasePtr creationChange(QNode *frontend) const;
 
     template<class Backend>
     void simulateInitializationSync(QNode *frontend, Backend *backend)
@@ -70,8 +66,6 @@ public:
         backend->setEnabled(frontend->isEnabled());
         backend->syncFromFrontEnd(frontend, true);
     }
-
-    void simulateInitialization(QNode *frontend, QBackendNode *backend);
 };
 
 } // namespace Qt3DCore
diff --git a/tests/auto/core/common/testarbiter.h b/tests/auto/core/common/testarbiter.h
new file mode 100644
index 000000000..1c1723fc1
--- /dev/null
+++ b/tests/auto/core/common/testarbiter.h
@@ -0,0 +1,64 @@
+/****************************************************************************
+**
+** Copyright (C) 2020 Klaralvdalens Datakonsult AB (KDAB).
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the Qt3D module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL3$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPLv3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or later as published by the Free
+** Software Foundation and appearing in the file LICENSE.GPL included in
+** the packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 2.0 requirements will be
+** met: http://www.gnu.org/licenses/gpl-2.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <Qt3DCore/private/qchangearbiter_p.h>
+#include <Qt3DCore/private/qnode_p.h>
+
+QT_BEGIN_NAMESPACE
+
+class TestArbiter : public Qt3DCore::QChangeArbiter
+{
+public:
+
+    void setArbiterOnNode(Qt3DCore::QNode *node)
+    {
+        Qt3DCore::QNodePrivate::get(node)->setArbiter(this);
+        const auto childNodes = node->childNodes();
+        for (Qt3DCore::QNode *n : childNodes)
+            setArbiterOnNode(n);
+    }
+
+    QVector<Qt3DCore::QNode *> dirtyNodes() const { return m_dirtyFrontEndNodes; }
+    QVector<Qt3DCore::ComponentRelationshipChange> dirtyComponents() const { return m_dirtyEntityComponentNodeChanges; }
+
+    void clear()
+    {
+        m_dirtyFrontEndNodes.clear();
+        m_dirtyEntityComponentNodeChanges.clear();
+    }
+};
+
+QT_END_NAMESPACE
diff --git a/tests/auto/core/common/testpostmanarbiter.cpp b/tests/auto/core/common/testpostmanarbiter.cpp
deleted file mode 100644
index f0c362744..000000000
--- a/tests/auto/core/common/testpostmanarbiter.cpp
+++ /dev/null
@@ -1,113 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
-#include "testpostmanarbiter.h"
-#include <Qt3DCore/private/qnode_p.h>
-
-QT_BEGIN_NAMESPACE
-
-TestPostman::TestPostman(TestArbiter *arbiter)
-    : m_arbiter(arbiter)
-{}
-
-void TestPostman::setScene(Qt3DCore::QScene *)
-{}
-
-void TestPostman::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &)
-{}
-
-void TestPostman::notifyBackend(const Qt3DCore::QSceneChangePtr &e)
-{
-    m_arbiter->sceneChangeEventWithLock(e);
-}
-
-bool TestPostman::shouldNotifyFrontend(const Qt3DCore::QSceneChangePtr &)
-{
-    return false;
-}
-
-TestArbiter::TestArbiter()
-    : m_postman(new TestPostman(this))
-{
-}
-
-TestArbiter::~TestArbiter()
-{
-}
-
-void TestArbiter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    events.push_back(e);
-}
-
-void TestArbiter::sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e)
-{
-    events.push_back(e);
-}
-
-void TestArbiter::sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &e)
-{
-    events += QVector<Qt3DCore::QSceneChangePtr>(e.begin(), e.end());
-}
-
-Qt3DCore::QAbstractPostman *TestArbiter::postman() const
-{
-    return m_postman;
-}
-
-void TestArbiter::setArbiterOnNode(Qt3DCore::QNode *node)
-{
-    Qt3DCore::QNodePrivate::get(node)->setArbiter(this);
-    const auto childNodes = node->childNodes();
-    for (Qt3DCore::QNode *n : childNodes)
-        setArbiterOnNode(n);
-}
-
-void TestArbiter::addDirtyFrontEndNode(Qt3DCore::QNode *node)
-{
-    if (!dirtyNodes.contains(node))
-        dirtyNodes << node;
-}
-
-void TestArbiter::addDirtyFrontEndNode(Qt3DCore::QNode *node, Qt3DCore::QNode *subNode, const char *property, Qt3DCore::ChangeFlag change)
-{
-    if (!dirtyNodes.contains(node))
-        dirtyNodes << node;
-    dirtySubNodes.push_back({node, subNode, change, property});
-}
-
-void TestArbiter::removeDirtyFrontEndNode(Qt3DCore::QNode *node)
-{
-    dirtyNodes.removeOne(node);
-}
-
-QT_END_NAMESPACE
diff --git a/tests/auto/core/common/testpostmanarbiter.h b/tests/auto/core/common/testpostmanarbiter.h
deleted file mode 100644
index e927c2489..000000000
--- a/tests/auto/core/common/testpostmanarbiter.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#include <Qt3DCore/private/qpostman_p.h>
-#include <Qt3DCore/private/qchangearbiter_p.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DCore {
-    class QNode;
-} // Qt3D
-
-class TestArbiter;
-
-class TestPostman : public Qt3DCore::QAbstractPostman
-{
-public:
-    explicit TestPostman(TestArbiter *arbiter);
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) final;
-    void setScene(Qt3DCore::QScene *) final;
-    void notifyBackend(const Qt3DCore::QSceneChangePtr &e) final;
-    bool shouldNotifyFrontend(const Qt3DCore::QSceneChangePtr &e) final;
-
-private:
-    TestArbiter *m_arbiter;
-};
-
-class TestArbiter : public Qt3DCore::QAbstractArbiter
-{
-public:
-    TestArbiter();
-    ~TestArbiter();
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) final;
-
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e) final;
-
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &e) final;
-
-    Qt3DCore::QAbstractPostman *postman() const final;
-
-    QVector<Qt3DCore::QSceneChangePtr> events;
-    QVector<Qt3DCore::QNode *> dirtyNodes;
-    QVector<Qt3DCore::NodeRelationshipChange> dirtySubNodes;
-
-    void setArbiterOnNode(Qt3DCore::QNode *node);
-    void addDirtyFrontEndNode(Qt3DCore::QNode *node) final;
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_DEPRECATED
-    void addDirtyFrontEndNode(Qt3DCore::QNode *node, Qt3DCore::QNode *subNode, const char *property, Qt3DCore::ChangeFlag change) final;
-    QT_WARNING_POP
-    void removeDirtyFrontEndNode(Qt3DCore::QNode *node) final;
-
-private:
-    TestPostman *m_postman;
-};
-
-QT_END_NAMESPACE
diff --git a/tests/auto/core/core.pro b/tests/auto/core/core.pro
index 3e4a8479d..a22402c3e 100644
--- a/tests/auto/core/core.pro
+++ b/tests/auto/core/core.pro
@@ -20,7 +20,6 @@ qtConfig(private_tests) {
         qentity \
         qtransform \
         threadpooler \
-        qpostman \
         vector4d_base \
         vector3d_base \
         aspectcommanddebugger \
diff --git a/tests/auto/core/nodes/tst_nodes.cpp b/tests/auto/core/nodes/tst_nodes.cpp
index c39638754..39560938a 100644
--- a/tests/auto/core/nodes/tst_nodes.cpp
+++ b/tests/auto/core/nodes/tst_nodes.cpp
@@ -26,10 +26,6 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
 #include <Qt3DCore/qnode.h>
 #include <Qt3DCore/qentity.h>
@@ -37,22 +33,14 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DCore/qaspectengine.h>
 #include <Qt3DCore/qabstractaspect.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qcomponentaddedchange.h>
-#include <Qt3DCore/qcomponentremovedchange.h>
-#include <Qt3DCore/qnodedestroyedchange.h>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/private/qaspectengine_p.h>
 #include <Qt3DCore/private/qaspectengine_p.h>
 #include <private/qabstractaspect_p.h>
-#include <private/qpostman_p.h>
 
-#include <Qt3DCore/private/qlockableobserverinterface_p.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qcomponent_p.h>
 #include <QSignalSpy>
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_Nodes : public QObject
 {
@@ -110,7 +98,6 @@ private slots:
 
     void checkDefaultConstruction();
     void checkPropertyChanges();
-    void checkCreationData();
     void checkEnabledUpdate();
     void checkPropertyTrackModeUpdate();
     void checkTrackedPropertyNamesUpdate();
@@ -118,100 +105,6 @@ private slots:
     void checkNodeRemovedFromDirtyListOnDestruction();
 };
 
-class ObserverSpy;
-class SimplePostman : public Qt3DCore::QAbstractPostman
-{
-public:
-    SimplePostman(ObserverSpy *spy)
-        : m_spy(spy)
-    {}
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) final {}
-    void setScene(Qt3DCore::QScene *) final {}
-    void notifyBackend(const Qt3DCore::QSceneChangePtr &change) final;
-    bool shouldNotifyFrontend(const Qt3DCore::QSceneChangePtr &changee) final { Q_UNUSED(changee); return false; }
-
-private:
-    ObserverSpy *m_spy;
-};
-
-class ObserverSpy : public Qt3DCore::QAbstractArbiter
-{
-public:
-    class ChangeRecord : public QPair<Qt3DCore::QSceneChangePtr, bool>
-    {
-    public:
-        ChangeRecord(const Qt3DCore::QSceneChangePtr &event, bool locked)
-            : QPair<Qt3DCore::QSceneChangePtr, bool>(event, locked)
-        {}
-
-        Qt3DCore::QSceneChangePtr change() const { return first; }
-
-        bool wasLocked() const { return second; }
-    };
-
-    ObserverSpy()
-        : Qt3DCore::QAbstractArbiter()
-        , m_postman(new SimplePostman(this))
-    {
-    }
-
-    ~ObserverSpy();
-
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e) override
-    {
-        events << ChangeRecord(e, true);
-    }
-
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &e) override
-    {
-        for (size_t i = 0, m = e.size(); i < m; ++i) {
-            events << ChangeRecord(e.at(i), false);
-        }
-    }
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override
-    {
-        events << ChangeRecord(e, false);
-    }
-
-    Qt3DCore::QAbstractPostman *postman() const final
-    {
-        return m_postman.data();
-    }
-
-    void addDirtyFrontEndNode(Qt3DCore::QNode *node) final {
-        if (!dirtyNodes.contains(node))
-            dirtyNodes << node;
-    }
-
-    void addDirtyFrontEndNode(Qt3DCore::QNode *node, Qt3DCore::QNode *subNode, const char *property, Qt3DCore::ChangeFlag change) final {
-        if (!dirtyNodes.contains(node))
-            dirtyNodes << node;
-        dirtySubNodes.push_back({node, subNode, change, property});
-    }
-
-    void removeDirtyFrontEndNode(Qt3DCore::QNode *node) final {
-        dirtyNodes.removeOne(node);
-    }
-
-    QVector<Qt3DCore::QNode *> dirtyNodes;
-    QVector<Qt3DCore::NodeRelationshipChange> dirtySubNodes;
-    QList<ChangeRecord> events;
-    QScopedPointer<SimplePostman> m_postman;
-};
-
-ObserverSpy::~ObserverSpy()
-{
-}
-
-void SimplePostman::notifyBackend(const Qt3DCore::QSceneChangePtr &change)
-{
-    m_spy->sceneChangeEventWithLock(change);
-}
-
-
-
 class MyQNode : public Qt3DCore::QNode
 {
     Q_OBJECT
@@ -241,7 +134,7 @@ public:
         return m_customProperty;
     }
 
-    void setArbiterAndScene(Qt3DCore::QAbstractArbiter *arbiter,
+    void setArbiterAndScene(Qt3DCore::QChangeArbiter *arbiter,
                             Qt3DCore::QScene *scene = nullptr)
     {
         Q_ASSERT(arbiter);
@@ -296,14 +189,14 @@ public slots:
             if (!attribute->parent())
                 attribute->setParent(this);
 
-            d->updateNode(attribute, "attribute", Qt3DCore::PropertyValueAdded);
+            d->update();
         }
     }
 
     void removeAttribute(MyQNode *attribute)
     {
         Qt3DCore::QNodePrivate *d = Qt3DCore::QNodePrivate::get(this);
-        d->updateNode(attribute, "attribute", Qt3DCore::PropertyValueRemoved);
+        d->update();
 
         m_attributes.removeOne(attribute);
         // Remove bookkeeping connection
@@ -333,7 +226,7 @@ public:
     {
     }
 
-    void setArbiterAndScene(Qt3DCore::QAbstractArbiter *arbiter,
+    void setArbiterAndScene(Qt3DCore::QChangeArbiter *arbiter,
                             Qt3DCore::QScene *scene = nullptr)
     {
         Q_ASSERT(arbiter);
@@ -343,7 +236,7 @@ public:
         Qt3DCore::QNodePrivate::get(this)->setArbiter(arbiter);
     }
 
-    void setArbiterAndEngine(Qt3DCore::QAbstractArbiter *arbiter,
+    void setArbiterAndEngine(Qt3DCore::QChangeArbiter *arbiter,
                             Qt3DCore::QAspectEngine *engine)
     {
         Q_ASSERT(arbiter);
@@ -383,7 +276,7 @@ public:
             if (!attribute->parent())
                 attribute->setParent(this);
 
-            d->updateNode(attribute, "attribute", Qt3DCore::PropertyValueRemoved);
+            d->update();
         }
     }
 
@@ -423,7 +316,7 @@ class MyQComponent : public Qt3DCore::QComponent
 public:
     explicit MyQComponent(Qt3DCore::QNode *parent = nullptr) : QComponent(parent)
     {}
-    void setArbiter(Qt3DCore::QAbstractArbiter *arbiter)
+    void setArbiter(Qt3DCore::QChangeArbiter *arbiter)
     {
         Q_ASSERT(arbiter);
         Qt3DCore::QComponentPrivate::get(this)->setArbiter(arbiter);
@@ -442,7 +335,7 @@ public:
     {
     }
 
-    void setArbiter(Qt3DCore::QAbstractArbiter *arbiter)
+    void setArbiter(Qt3DCore::QChangeArbiter *arbiter)
     {
         Q_ASSERT(arbiter);
         Qt3DCore::QComponentPrivate::get(this)->setArbiter(arbiter);
@@ -501,11 +394,11 @@ class TestFunctor : public Qt3DCore::QBackendNodeMapper
 public:
     TestFunctor(TestAspect *aspect) : m_aspect(aspect) {}
 
-    Qt3DCore::QBackendNode *create(const Qt3DCore::QNodeCreatedChangeBasePtr &change) const override
+    Qt3DCore::QBackendNode *create(Qt3DCore::QNodeId id) const override
     {
         auto node = new Qt3DCore::QBackendNode;
-        m_Nodes.insert(change->subjectId(), node);
-        m_aspect->addEvent(change->subjectId(), TestAspect::Creation);
+        m_Nodes.insert(id, node);
+        m_aspect->addEvent(id, TestAspect::Creation);
         return node;
     }
 
@@ -545,10 +438,10 @@ public:
 
 TestAspect::TestAspect(QObject *parent) : TestAspect(*new TestAspectPrivate, parent)
 {
-    registerBackendType<Qt3DCore::QEntity, true>(QSharedPointer<TestFunctor>::create(this));
-    registerBackendType<MyQEntity, true>(QSharedPointer<TestFunctor>::create(this));
-    registerBackendType<MyQNode, true>(QSharedPointer<TestFunctor>::create(this));
-    registerBackendType<Qt3DCore::QNode, true>(QSharedPointer<TestFunctor>::create(this));
+    registerBackendType<Qt3DCore::QEntity>(QSharedPointer<TestFunctor>::create(this));
+    registerBackendType<MyQEntity>(QSharedPointer<TestFunctor>::create(this));
+    registerBackendType<MyQNode>(QSharedPointer<TestFunctor>::create(this));
+    registerBackendType<Qt3DCore::QNode>(QSharedPointer<TestFunctor>::create(this));
 }
 
 TestAspect::TestAspect(TestAspectPrivate &dd, QObject *parent)
@@ -625,9 +518,9 @@ void tst_Nodes::appendSingleChildNodeToNodeNoSceneExplicitParenting()
 {
     // Check nodes added when no scene is set
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> node(new MyQNode());
-    node->setArbiterAndScene(&spy);
+    node->setArbiterAndScene(&arbiter);
 
     // THEN
     QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() == nullptr);
@@ -646,16 +539,16 @@ void tst_Nodes::appendSingleChildNodeToNodeNoSceneExplicitParenting()
     QCOMPARE(node->children().count(), 1);
 
     // Events are only sent when a scene is set on the root node
-    QCOMPARE(spy.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 }
 
 void tst_Nodes::appendSingleChildNodeToNodeNoSceneImplicitParenting()
 {
     // Check nodes added when no scene is set
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> node(new MyQNode());
-    node->setArbiterAndScene(&spy);
+    node->setArbiterAndScene(&arbiter);
 
     // THEN
     QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() == nullptr);
@@ -669,16 +562,16 @@ void tst_Nodes::appendSingleChildNodeToNodeNoSceneImplicitParenting()
     QCOMPARE(node->children().count(), 1);
 
     // Events are only sent when a scene is set on the root node
-    QCOMPARE(spy.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 }
 
 void tst_Nodes::appendMultipleChildNodesToNodeNoScene()
 {
     // Check multiple nodes added with no scene set
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> node(new MyQNode());
-    node->setArbiterAndScene(&spy);
+    node->setArbiterAndScene(&arbiter);
 
     // THEN
     QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() == nullptr);
@@ -701,7 +594,7 @@ void tst_Nodes::appendMultipleChildNodesToNodeNoScene()
     QCOMPARE(node->children().count(), 10);
 
     // Events are only sent when a scene is set on the root node
-    QCOMPARE(spy.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 }
 
 void tst_Nodes::appendSingleChildNodeToNodeSceneExplicitParenting()
@@ -709,10 +602,10 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneExplicitParenting()
     // Check nodes added when scene is set
     // GIVEN
     Qt3DCore::QScene scene;
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> node(new MyQNode());
     // WHEN
-    node->setArbiterAndScene(&spy, &scene);
+    node->setArbiterAndScene(&arbiter, &scene);
     node->setSimulateBackendCreated(true);
 
     // THEN
@@ -731,17 +624,9 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneExplicitParenting()
     // THEN
     QVERIFY(child->parent() == node.data());
     QVERIFY(child->parentNode() == node.data());
-    QCOMPARE(spy.events.size(), 1); // Child Added
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // Child Added
     QCOMPARE(node->children().count(), 1);
     QVERIFY(Qt3DCore::QNodePrivate::get(child.data())->scene() != nullptr);
-
-    // Node Added event
-    QVERIFY(spy.events.first().wasLocked());
-    Qt3DCore::QPropertyNodeAddedChangePtr additionEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-    QVERIFY(additionEvent);
-    QCOMPARE(additionEvent->subjectId(), node->id());
-    QCOMPARE(additionEvent->addedNodeId(), child->id());
-    QCOMPARE(additionEvent->metaObject(), child->metaObject());
 }
 
 void tst_Nodes::appendSingleChildNodeToNodeSceneImplicitParenting()
@@ -749,11 +634,11 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneImplicitParenting()
     // Check nodes added when scene is set
     // GIVEN
     Qt3DCore::QScene scene;
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> node(new MyQNode());
 
     // WHEN
-    node->setArbiterAndScene(&spy, &scene);
+    node->setArbiterAndScene(&arbiter, &scene);
     // THEN
     QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() != nullptr);
 
@@ -766,17 +651,8 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneImplicitParenting()
     QVERIFY(child->parentNode() == node.data());
     QVERIFY(Qt3DCore::QNodePrivate::get(child.data())->scene() != nullptr);
 
-    QCOMPARE(spy.events.size(), 1);
-    QVERIFY(spy.events.first().wasLocked());
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
     QCOMPARE(node->children().count(), 1);
-
-    // Node Added event
-    QVERIFY(spy.events.first().wasLocked());
-    Qt3DCore::QPropertyNodeAddedChangePtr additionEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-    QVERIFY(additionEvent);
-    QCOMPARE(additionEvent->subjectId(), node->id());
-    QCOMPARE(additionEvent->addedNodeId(), child->id());
-    QCOMPARE(additionEvent->metaObject(), child->metaObject());
 }
 
 void tst_Nodes::appendMultipleChildNodesToNodeScene()
@@ -785,11 +661,11 @@ void tst_Nodes::appendMultipleChildNodesToNodeScene()
 
     // GIVEN
     Qt3DCore::QScene scene;
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> node(new MyQNode());
 
     // WHEN
-    node->setArbiterAndScene(&spy, &scene);
+    node->setArbiterAndScene(&arbiter, &scene);
     node->setSimulateBackendCreated(true);
     // THEN
     QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() != nullptr);
@@ -816,89 +692,53 @@ void tst_Nodes::appendMultipleChildNodesToNodeScene()
     // WHEN
     QCoreApplication::processEvents();
 
-    // THEN backend is notified after the event loop spins. The recorded events are a little
-    // tricky to understand and differs for children with the parent being set at construction
-    // time (even children and ids) and the children being created without a parent and then
-    // explicitly calling setParent() after (odd children and ids).
-    //
-    // Even children:
-    //   child constructed
-    //   notifications to backend scheduled via the event loop as object is not yet fully constructed
-    //
-    // Odd children:
-    //   child constructed
-    //   parent set
-    //   notifications to backend sent immediately as object is fully constructed
-    //
-    // With this in mind, the recorded events should show:
-    //
-    // for each odd child:
-    //   child addition to parent of odd child
-    //
-    // followed by:
-    //
-    // for each even child:
-    //   child addition to parent of even child
-    //
-    const auto expectedEventCount = childCount;
-    QCOMPARE(spy.events.size(), 10);
-
-    for (auto i = 0; i < expectedEventCount; ++i) {
-        const auto childIndex = i;
-        Qt3DCore::QNode *child = node->childNodes().at(childIndex);
-
-        const auto recordIndex = (i % 2 == 0) ? expectedEventCount / 2 + i / 2 : i / 2;
-        const auto additionRecord = spy.events.at(recordIndex);
-        Qt3DCore::QPropertyNodeAddedChangePtr additionEvent = additionRecord.change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(additionEvent->subjectId(), node->id());
-        QCOMPARE(additionEvent->addedNodeId(), child->id());
-        QCOMPARE(additionEvent->metaObject(), child->metaObject());
-    }
+    // THEN backend is notified after the event loop spins. Only the parent is notified
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
 }
 
 void tst_Nodes::checkParentChangeToNull()
 {
     // GIVEN
     Qt3DCore::QScene scene;
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> root(new MyQNode());
 
     // WHEN
-    root->setArbiterAndScene(&spy, &scene);
+    root->setArbiterAndScene(&arbiter, &scene);
     QScopedPointer<Qt3DCore::QNode> child(new MyQNode(root.data()));
     QCoreApplication::processEvents();
 
     // THEN
     QVERIFY(child->parent() == root.data());
-    QCOMPARE(spy.events.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
     QCOMPARE(root->children().size(), 1);
 
     // WHEN
-    spy.events.clear();
+    arbiter.clear();
     child->setParent(Q_NODE_NULLPTR);
 
     // THEN
     QVERIFY(child->parent() == nullptr);
     QCOMPARE(root->children().size(), 0);
-    QCOMPARE(spy.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 }
 
 void tst_Nodes::checkParentChangeToOtherParent()
 {
     // GIVEN
     Qt3DCore::QScene scene;
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> root(new MyQNode());
-    root->setArbiterAndScene(&spy, &scene);
+    root->setArbiterAndScene(&arbiter, &scene);
     QScopedPointer<MyQNode> parent1(new MyQNode(root.data()));
     QScopedPointer<MyQNode> parent2(new MyQNode(root.data()));
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(spy.events.size(), 2); // 2 x (1 node added to children change)
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // only parent node has changed
 
     // WHEN
-    spy.events.clear();
+    arbiter.clear();
     QScopedPointer<Qt3DCore::QNode> child(new MyQNode(parent1.data()));
     QCoreApplication::processEvents();
 
@@ -907,48 +747,32 @@ void tst_Nodes::checkParentChangeToOtherParent()
     QCOMPARE(parent1->children().size(), 1);
     QCOMPARE(parent2->children().size(), 0);
     QVERIFY(Qt3DCore::QNodePrivate::get(child.data())->scene() != nullptr);
-    QCOMPARE(spy.events.size(), 1); // 1 node added to children change
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // 1 node added to children change
 
     // WHEN
-    spy.events.clear();
+    arbiter.clear();
     child->setParent(parent2.data());
 
     // THEN
     QVERIFY(child->parent() == parent2.data());
     QCOMPARE(parent1->children().size(), 0);
     QCOMPARE(parent2->children().size(), 1);
-    QCOMPARE(spy.events.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
     // CHECK event 1 is a Node Removed event
     // this no longer generated because nodes don't have backends yet
 
     QVERIFY(!Qt3DCore::QNodePrivate::get(child.data())->m_hasBackendNode);
-
-
-//    QVERIFY(spy.events.first().wasLocked());
-//    const Qt3DCore::QPropertyNodeRemovedChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
-//    QCOMPARE(event->type(), Qt3DCore::PropertyValueRemoved);
-//    QCOMPARE(event->subjectId(), parent1->id());
-//    QCOMPARE(event->removedNodeId(), child->id());
-//    QCOMPARE(event->metaObject(), child->metaObject());
-
-    // CHECK event 2 is a Node Added event
-    QVERIFY(spy.events.last().wasLocked());
-    const Qt3DCore::QPropertyNodeAddedChangePtr event2 = spy.events.last().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-    QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
-    QCOMPARE(event2->subjectId(), parent2->id());
-    QCOMPARE(event2->addedNodeId(), child->id());
-    QCOMPARE(event2->metaObject(), child->metaObject());
 }
 
 void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     engine.setRunMode(Qt3DCore::QAspectEngine::Manual);
     QScopedPointer<MyQEntity> root(new MyQEntity());
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     auto aspect = new TestAspect;
     engine.registerAspect(aspect);
 
@@ -967,11 +791,11 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
     QCOMPARE(aspect->events[1].nodeId, child2->id());
 
     // THEN
-    QCOMPARE(spy.events.size(), 2); // 2 x (1 child added to parent change)
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // only parent node has changed
 
     // WHEN -> Reparenting child with backend node to new parent with no backend yet
     aspect->clearNodes();
-    spy.events.clear();
+    arbiter.clear();
     QScopedPointer<Qt3DCore::QNode> newParent(new MyQNode(root.data()));
     child->setParent(newParent.data());
 
@@ -990,62 +814,17 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
     engine.processFrame();
 
     // THEN
-    QCOMPARE(spy.events.size(), 2);
-    // 1 node removed change
-    // 1 node added to children change
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // only parent node has changed
     QVERIFY(Qt3DCore::QNodePrivate::get(newParent.data())->m_hasBackendNode == true);
     QVERIFY(Qt3DCore::QNodePrivate::get(child)->m_hasBackendNode == true);
 
-    {
-        // CHECK event 1 is a Node Removed event
-        QVERIFY(spy.events.first().wasLocked());
-        const Qt3DCore::QPropertyNodeRemovedChangePtr event = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(event->type(), Qt3DCore::PropertyValueRemoved);
-        QCOMPARE(event->subjectId(), root->id());
-        QCOMPARE(event->removedNodeId(), child->id());
-        QCOMPARE(event->metaObject(), child->metaObject());
-
-        const Qt3DCore::QPropertyNodeAddedChangePtr event2 = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event2->addedNodeId(), newParent->id());
-        QCOMPARE(event2->metaObject(), newParent->metaObject());
-        QCOMPARE(event2->subjectId(), root->id());
-
-        QCOMPARE(aspect->events.count(), 3);
-
-        // child backend is destroyed because it was reparented to node without backend (newParent)
-        QCOMPARE(aspect->events[0].type, TestAspect::Destruction);
-        QCOMPARE(aspect->events[0].nodeId, child->id());
-
-        // newParent and child both get backends created
-        QCOMPARE(aspect->events[1].type, TestAspect::Creation);
-        QCOMPARE(aspect->events[1].nodeId, newParent->id());
-        QCOMPARE(aspect->events[2].type, TestAspect::Creation);
-        QCOMPARE(aspect->events[2].nodeId, child->id());
-    }
-
     // WHEN -> Changing parent to node with existing backend
     aspect->clearNodes();
     child->setParent(child2);
 
     // THEN
-    QCOMPARE(spy.events.size(), 2);
-
-    // 1 node removed change, 1 node added change
-    {
-        QVERIFY(spy.events.first().wasLocked());
-        const Qt3DCore::QPropertyNodeRemovedChangePtr event = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(event->type(), Qt3DCore::PropertyValueRemoved);
-        QCOMPARE(event->subjectId(), newParent->id());
-        QCOMPARE(event->removedNodeId(), child->id());
-        QCOMPARE(event->metaObject(), child->metaObject());
-
-        const Qt3DCore::QPropertyNodeAddedChangePtr event2 = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event2->addedNodeId(), child->id());
-        QCOMPARE(event2->metaObject(), child->metaObject());
-        QCOMPARE(event2->subjectId(), child2->id());
-    }
+    QCOMPARE(arbiter.dirtyNodes().size(), 3); // old parent, new parent, and child have all changed
+    arbiter.clear();
 
     QVERIFY(Qt3DCore::QNodePrivate::get(child)->m_hasBackendNode == true);
     QCOMPARE(root->childNodes().size(), 2);
@@ -1067,28 +846,7 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
     engine.processFrame();
 
     // THEN
-    QCOMPARE(spy.events.size(), 2);
-    // 1 node removed change
-    // 1 node added to children change
-    {
-        // CHECK event 1 is a Node Removed event
-        QVERIFY(spy.events.first().wasLocked());
-        const Qt3DCore::QPropertyNodeRemovedChangePtr event = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(event->type(), Qt3DCore::PropertyValueRemoved);
-        QCOMPARE(event->subjectId(), child2->id());
-        QCOMPARE(event->removedNodeId(), child->id());
-        QCOMPARE(event->metaObject(), child->metaObject());
-
-        const Qt3DCore::QPropertyNodeAddedChangePtr event2 = spy.events.takeFirst().change().staticCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event2->addedNodeId(), newParent2->id());
-        QCOMPARE(event2->metaObject(), newParent2->metaObject());
-        QCOMPARE(event2->subjectId(), root->id());
-
-        // child backend is destroyed because it was reparented to node without backend (newParent)
-        QCOMPARE(aspect->events[0].type, TestAspect::Destruction);
-        QCOMPARE(aspect->events[0].nodeId, child->id());
-    }
+    QCOMPARE(arbiter.dirtyNodes().size(), 2);
 }
 
 //Test creation changes happen for an entire subtree at once, starting at the top
@@ -1097,13 +855,13 @@ void tst_Nodes::checkParentChangeFromExistingBackendParentToNewlyCreatedParent()
 void tst_Nodes::checkBackendNodesCreatedFromTopDown()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     auto aspect = new TestAspect;
     engine.registerAspect(aspect);
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     QScopedPointer<Qt3DCore::QNode> parentWithBackend(new MyQNode(root.data()));
 
     // create parent backend node
@@ -1112,14 +870,14 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDown()
 
     // WHEN -> creating 3 nodes and setting one as a property on the other
     //         child2 is set as property on child1, but is created AFTER child1
-    spy.events.clear();
+    arbiter.clear();
     MyQNode *dummyParent(new MyQNode(parentWithBackend.data()));
     MyQNode *child1(new MyQNode(parentWithBackend.data()));
     MyQNode *child2(new MyQNode(dummyParent));
     child1->setNodeProperty(child2);
 
     // THEN - we should have no events because the new nodes have no backend yet
-    QCOMPARE(spy.events.count(), 0);
+    QCOMPARE(arbiter.dirtyNodes().count(), 0);
 
     // WHEN - create the backend nodes
     QCoreApplication::processEvents();
@@ -1130,27 +888,13 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDown()
     QVERIFY(child2->parent() == dummyParent);
 
     // THEN
-    QCOMPARE(spy.events.size(), 2);
-    // 1 node added to children change (dummyParent to parent)
-    // 1 node added to children change (child1 to parent)
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // only parent node has changed
 
     {
         QVERIFY(Qt3DCore::QNodePrivate::get(dummyParent)->m_hasBackendNode);
         QVERIFY(Qt3DCore::QNodePrivate::get(child1)->m_hasBackendNode);
         QVERIFY(Qt3DCore::QNodePrivate::get(child2)->m_hasBackendNode);
 
-        // 1st event: dummyParent added to parent
-        const auto event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event->addedNodeId(), dummyParent->id());
-        QCOMPARE(event->subjectId(), parentWithBackend->id());
-
-        // 2nd event: child 1 added to parent
-        const auto event2 = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-        QCOMPARE(event2->type(), Qt3DCore::PropertyValueAdded);
-        QCOMPARE(event2->addedNodeId(), child1->id());
-        QCOMPARE(event2->subjectId(), parentWithBackend->id());
-
         verifyChildrenCreatedBeforeParents(root.get(), aspect);
     }
 
@@ -1159,13 +903,13 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDown()
 void tst_Nodes::checkBackendNodesCreatedFromTopDownWithReparenting()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     auto aspect = new TestAspect;
     engine.registerAspect(aspect);
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     QScopedPointer<Qt3DCore::QNode> parentWithBackend(new MyQNode(root.data()));
 
     // create parent backend node
@@ -1175,7 +919,7 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDownWithReparenting()
 
     // WHEN -> creating a node with a parent with backend, then reparenting it to another
     // parent with backend created after it.
-    spy.events.clear();
+    arbiter.clear();
     auto node1 = new MyQNode(parentWithBackend.data());
     auto parent1 = new MyQNode(parentWithBackend.data());
     node1->setParent(parent1);
@@ -1205,18 +949,18 @@ void tst_Nodes::checkBackendNodesCreatedFromTopDownWithReparenting()
 void tst_Nodes::removingSingleChildNodeFromNode()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     QScopedPointer<MyQEntity> root(new MyQEntity());
     QScopedPointer<Qt3DCore::QNode> child(new MyQNode());
 
     // WHEN
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     root->setSimulateBackendCreated(true);
     child->setParent(root.data());
 
     // Clear any creation event
-    spy.events.clear();
+    arbiter.clear();
 
     // THEN
     QVERIFY(root->children().count() == 1);
@@ -1229,26 +973,20 @@ void tst_Nodes::removingSingleChildNodeFromNode()
     QVERIFY(child->parent() == nullptr);
     QVERIFY(root->children().count() == 0);
 
-    QCOMPARE(spy.events.size(), 1);
-
-    QVERIFY(spy.events.first().wasLocked());
-    const Qt3DCore::QPropertyNodeRemovedChangePtr removalEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
-    QCOMPARE(removalEvent->subjectId(), root->id());
-    QCOMPARE(removalEvent->removedNodeId(), child->id());
-    QCOMPARE(removalEvent->metaObject(), child->metaObject());
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
 }
 
 void tst_Nodes::checkAllBackendCreationDoneInSingleFrame()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     engine.setRunMode(Qt3DCore::QAspectEngine::Manual);
     auto aspect = new TestAspect;
     engine.registerAspect(aspect);
 
     QScopedPointer<MyQEntity> root(new MyQEntity());
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
 
     QCoreApplication::processEvents();
 
@@ -1289,12 +1027,12 @@ void tst_Nodes::checkAllBackendCreationDoneInSingleFrame()
 void tst_Nodes::removingMultipleChildNodesFromNode()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
     // WHEN
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
 
     // THEN
     QVERIFY(Qt3DCore::QNodePrivate::get(root.data())->scene() != nullptr);
@@ -1310,26 +1048,16 @@ void tst_Nodes::removingMultipleChildNodesFromNode()
 
     // THEN
     QCOMPARE(root->children().count(), 10);
-    QCOMPARE(spy.events.size(), 10);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
     // WHEN
-    spy.events.clear();
+    arbiter.clear();
     auto cl = root->children();
     qDeleteAll(cl);
 
     // THEN
     QVERIFY(root->children().count() == 0);
-    QCOMPARE(spy.events.size(), 10);
-    int i = 0;
-    for (const ObserverSpy::ChangeRecord &r : qAsConst(spy.events)) {
-        QVERIFY(r.wasLocked());
-        const Qt3DCore::QNodeId childId = childIds.at(i);
-        Qt3DCore::QPropertyNodeRemovedChangePtr additionEvent = r.change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
-        QCOMPARE(additionEvent->subjectId(), root->id());
-        QCOMPARE(additionEvent->removedNodeId(), childId);
-        QCOMPARE(additionEvent->metaObject(), &MyQNode::staticMetaObject);
-        ++i;
-    }
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);   // since all nodes are deleted, there's no backend to notify
 }
 
 void tst_Nodes::appendingChildEntitiesToNode()
@@ -1373,14 +1101,14 @@ void tst_Nodes::removingChildEntitiesFromNode()
 void tst_Nodes::checkConstructionSetParentMix()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     auto aspect = new TestAspect;
     engine.registerAspect(aspect);
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
     // WHEN
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     root->setSimulateBackendCreated(true);
 
     // THEN
@@ -1398,27 +1126,21 @@ void tst_Nodes::checkConstructionSetParentMix()
     QCoreApplication::processEvents();
     QCOMPARE(root->children().count(), 1);
     QCOMPARE(subTreeRoot->children().count(), 100);
-    QCOMPARE(spy.events.size(), 1); // 1 child added (subTree to root)
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // 1 child added (subTree to root)
 
     // Ensure first event is subTreeRoot
     verifyChildrenCreatedBeforeParents(root.data(), aspect);
-
-    const Qt3DCore::QPropertyNodeAddedChangePtr lastEvent = spy.events.takeLast().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-    QVERIFY(!lastEvent.isNull());
-    QCOMPARE(lastEvent->subjectId(), root->id());
-    QCOMPARE(lastEvent->propertyName(), "children");
-    QCOMPARE(lastEvent->addedNodeId(), subTreeRoot->id());
 }
 
 void tst_Nodes::checkParentingQEntityToQNode()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
     // WHEN
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     root->setSimulateBackendCreated(true);
 
     // THEN
@@ -1431,7 +1153,7 @@ void tst_Nodes::checkParentingQEntityToQNode()
 
     // THEN
     QCoreApplication::processEvents();
-    QCOMPARE(spy.events.size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
     QVERIFY(Qt3DCore::QNodePrivate::get(root.data())->m_hasBackendNode);
     QVERIFY(Qt3DCore::QNodePrivate::get(subTreeRoot)->m_hasBackendNode);
@@ -1439,43 +1161,23 @@ void tst_Nodes::checkParentingQEntityToQNode()
     QVERIFY(Qt3DCore::QNodePrivate::get(childNode)->m_hasBackendNode);
 
     // WHEN we reparent the childEntity to the childNode (QNode)
-    spy.events.clear();
+    arbiter.clear();
     childEntity->setParent(childNode);
     QCoreApplication::processEvents();
 
-    // THEN we should get
-    // - one child removed change for childEntity->subTreeRoot,
-    // - one child added change for childEntity->childNode,
-    QCOMPARE(spy.events.size(), 2);
-
-    const auto removedEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeRemovedChange>();
-    QVERIFY(!removedEvent.isNull());
-    QCOMPARE(removedEvent->subjectId(), subTreeRoot->id());
-
-    const auto addedEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-    QVERIFY(!addedEvent.isNull());
-    QCOMPARE(addedEvent->subjectId(), childNode->id());
-
-    // The arbiter's dirtyNodes should contain the childEntity and
-    //  - the dirty node's parent should be childNode
-    //  - the dirty node's parent entity should be the subTreeRoot
-    QCOMPARE(spy.dirtyNodes.size(), 1);
-    const auto dirtyEntity = qobject_cast<Qt3DCore::QEntity*>(spy.dirtyNodes.takeFirst());
-    QVERIFY(dirtyEntity);
-    QCOMPARE(dirtyEntity, childEntity);
-    QCOMPARE(dirtyEntity->parent(), childNode);
-    QCOMPARE(dirtyEntity->parentEntity(), subTreeRoot);
+    // THEN
+    QCOMPARE(arbiter.dirtyNodes().size(), 3);
 }
 
 void tst_Nodes::checkConstructionWithParent()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
     // WHEN
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     root->setSimulateBackendCreated(true);
 
     // THEN
@@ -1488,29 +1190,19 @@ void tst_Nodes::checkConstructionWithParent()
     // THEN we should get one child added change
     QCoreApplication::processEvents();
     QCOMPARE(root->children().count(), 1);
-    QCOMPARE(spy.events.size(), 1); // 1 child added change
-
-    const auto newChildEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-    QVERIFY(!newChildEvent.isNull());
-    QCOMPARE(newChildEvent->subjectId(), root->id());
-    QCOMPARE(newChildEvent->propertyName(), "children");
-    QCOMPARE(newChildEvent->addedNodeId(), node->id());
-
-    // Ensure the parent node is dirty
-    QCOMPARE(spy.events.size(), 0);
-    QCOMPARE(spy.dirtyNodes.size(), 1);
-    QCOMPARE(spy.dirtyNodes.front(), root.data());
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // 1 child added change
+    QCOMPARE(arbiter.dirtyNodes().front(), root.data());
 }
 
 void tst_Nodes::checkConstructionWithNonRootParent()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
     // WHEN
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     root->setSimulateBackendCreated(true);
     QScopedPointer<MyQNode> parent(new MyQNode(root.data()));
 
@@ -1532,28 +1224,19 @@ void tst_Nodes::checkConstructionWithNonRootParent()
     QCOMPARE(root->children().count(), 1);
     QCOMPARE(parent->children().count(), 1);
 
-    QCOMPARE(spy.events.size(), 1); // 1 child added changes
-
-    const auto parentNewChildEvent = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-    QVERIFY(!parentNewChildEvent.isNull());
-    QCOMPARE(parentNewChildEvent->subjectId(), root->id());
-    QCOMPARE(parentNewChildEvent->propertyName(), "children");
-    QCOMPARE(parentNewChildEvent->addedNodeId(), parent->id());
-
-    // Ensure second and last event is property set change
-    QCOMPARE(spy.dirtyNodes.size(), 1);
-    QCOMPARE(spy.dirtyNodes.front(), root.data());
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // 1 child added changes
+    QCOMPARE(arbiter.dirtyNodes().front(), root.data());
 }
 
 void tst_Nodes::checkConstructionAsListElement()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     QScopedPointer<MyQEntity> root(new MyQEntity());
 
     // WHEN
-    root->setArbiterAndEngine(&spy, &engine);
+    root->setArbiterAndEngine(&arbiter, &engine);
     root->setSimulateBackendCreated(true);
 
     // THEN
@@ -1568,19 +1251,18 @@ void tst_Nodes::checkConstructionAsListElement()
     QCoreApplication::processEvents();
 
     QCOMPARE(root->children().count(), 1);
-    QCOMPARE(spy.dirtyNodes.size(), 1); // 1 property change
-    QCOMPARE(spy.dirtySubNodes.size(), 1); // 1 child added change
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // 1 property change
 }
 
 void tst_Nodes::checkSceneIsSetOnConstructionWithParent()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QScene scene;
     QScopedPointer<MyQNode> root(new MyQNode());
 
     // WHEN
-    root->setArbiterAndScene(&spy, &scene);
+    root->setArbiterAndScene(&arbiter, &scene);
     root->setSimulateBackendCreated(true);
 
     // THEN
@@ -1603,9 +1285,9 @@ void tst_Nodes::checkSceneIsSetOnConstructionWithParent()
     QCoreApplication::processEvents();
     QCOMPARE(root->children().count(), 1);
     QCOMPARE(subTreeRoot->children().count(), 5);
-    QCOMPARE(spy.events.size(), 1); // 1 child added (subTree to root)
+    QCOMPARE(arbiter.dirtyNodes().size(), 1); // 1 child added (subTree to root)
 
-    spy.events.clear();
+    arbiter.clear();
 
     // Add component in a separate loop to ensure components are added after
     // entities have been fully created
@@ -1614,20 +1296,19 @@ void tst_Nodes::checkSceneIsSetOnConstructionWithParent()
     }
 
     // THEN
-    QCOMPARE(spy.events.size(), 0);
-    QCOMPARE(spy.dirtySubNodes.size(), 5); // 5 entities changed
+    QCOMPARE(arbiter.dirtyNodes().size(), 5);
 }
 
 void tst_Nodes::checkSubNodePostConstructIsCalledWhenReferincingNodeProperty()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
     Qt3DCore::QScene scene(&engine);
     QScopedPointer<MyQNode> root(new MyQNode());
 
     // WHEN
-    root->setArbiterAndScene(&spy, &scene);
+    root->setArbiterAndScene(&arbiter, &scene);
     root->setSimulateBackendCreated(true);
 
     // THEN
@@ -1649,33 +1330,19 @@ void tst_Nodes::checkSubNodePostConstructIsCalledWhenReferincingNodeProperty()
     QVERIFY(Qt3DCore::QNodePrivate::get(material->m_effect)->m_hasBackendNode);
     QVERIFY(Qt3DCore::QNodePrivate::get(material->m_technique)->m_hasBackendNode);
     QVERIFY(Qt3DCore::QNodePrivate::get(material->m_renderPass)->m_hasBackendNode);
-
-    // WHEN
-    MyQNode *fakeRenderState = new MyQNode(material);
-    Qt3DCore::QNodePrivate *dPtr = Qt3DCore::QNodePrivate::get(fakeRenderState);
-
-    // THEN
-    QVERIFY(!dPtr->m_hasBackendNode);
-
-    // WHEN
-    material->m_renderPass->addAttribute(fakeRenderState);
-
-    // THEN
-    QVERIFY(dPtr->m_hasBackendNode);
 }
 
 void tst_Nodes::appendingParentlessComponentToEntityWithoutScene()
 {
     // GIVEN
-    ObserverSpy entitySpy;
-    ObserverSpy componentSpy;
+    TestArbiter arbiter;
     {
         QScopedPointer<MyQEntity> entity(new MyQEntity());
-        entity->setArbiterAndScene(&entitySpy);
+        entity->setArbiterAndScene(&arbiter);
         entity->setSimulateBackendCreated(true);
 
         MyQComponent *comp = new MyQComponent();
-        comp->setArbiter(&componentSpy);
+        comp->setArbiter(&arbiter);
 
         // THEN
         QVERIFY(entity->parentNode() == nullptr);
@@ -1690,15 +1357,7 @@ void tst_Nodes::appendingParentlessComponentToEntityWithoutScene()
         QVERIFY(entity->components().count() == 1);
         QVERIFY(entity->components().first() == comp);
         QVERIFY(comp->parentNode() == entity.data());
-        QCOMPARE(entitySpy.events.size(), 0);
-        QCOMPARE(entitySpy.dirtyNodes.size(), 1);
-        QCOMPARE(entitySpy.dirtySubNodes.size(), 1);
-
-        const auto event = entitySpy.dirtySubNodes.first();
-        QCOMPARE(event.change, Qt3DCore::ComponentAdded);
-        QCOMPARE(event.node, entity.data());
-        QCOMPARE(event.subNode, comp);
-        QCOMPARE(event.property, nullptr);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
         // Note: since QEntity has no scene in this test case, we only have the
         // ComponentAdded event In theory we should also get the NodeCreated event
@@ -1711,12 +1370,12 @@ void tst_Nodes::appendingParentlessComponentToEntityWithoutScene()
 void tst_Nodes::appendingParentlessComponentToNonRootEntity()
 {
     // GIVEN
-    ObserverSpy eventSpy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
 
     {
         QScopedPointer<MyQEntity> root(new MyQEntity());
-        root->setArbiterAndEngine(&eventSpy, &engine);
+        root->setArbiterAndEngine(&arbiter, &engine);
         root->setSimulateBackendCreated(true);
 
         QCoreApplication::processEvents();
@@ -1742,33 +1401,24 @@ void tst_Nodes::appendingParentlessComponentToNonRootEntity()
         QVERIFY(entity->components().first() == comp);
         QVERIFY(comp->parentNode() == entity.data());
 
-        QCOMPARE(eventSpy.events.size(), 1);
-        // - entity added as child to root
-        QVERIFY(eventSpy.events.first().wasLocked());
+        QCOMPARE(arbiter.dirtyNodes().size(), 2);
+        QCOMPARE(arbiter.dirtyNodes().at(0), root.data());
+        QCOMPARE(arbiter.dirtyNodes().at(1), entity.data());
 
         QVERIFY(Qt3DCore::QNodePrivate::get(entity.data())->m_hasBackendNode);
         QVERIFY(Qt3DCore::QNodePrivate::get(comp)->m_hasBackendNode);
-
-        {
-            const auto event = eventSpy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QVERIFY(!event.isNull());
-            QCOMPARE(event->type(), Qt3DCore::PropertyValueAdded);
-            QCOMPARE(event->subjectId(), root->id());
-            QCOMPARE(event->propertyName(), QByteArrayLiteral("children"));
-            QCOMPARE(event->addedNodeId(), entity->id());
-        }
     }
 }
 
 void tst_Nodes::appendingParentlessComponentToEntityWithScene()
 {
     // GIVEN
-    ObserverSpy eventSpy;
+    TestArbiter arbiter;
     Qt3DCore::QAspectEngine engine;
 
     {
         QScopedPointer<MyQEntity> entity(new MyQEntity());
-        entity->setArbiterAndEngine(&eventSpy, &engine);
+        entity->setArbiterAndEngine(&arbiter, &engine);
         entity->setSimulateBackendCreated(true);
 
         QCoreApplication::processEvents();
@@ -1790,18 +1440,7 @@ void tst_Nodes::appendingParentlessComponentToEntityWithScene()
         QVERIFY(entity->components().first() == comp);
         QVERIFY(comp->parentNode() == entity.data());
 
-        QCOMPARE(eventSpy.events.size(), 1);
-        // - child added
-        QVERIFY(eventSpy.events.first().wasLocked());
-
-        {
-            const auto event = eventSpy.events.takeFirst().change().dynamicCast<Qt3DCore::QPropertyNodeAddedChange>();
-            QVERIFY(!event.isNull());
-            QCOMPARE(event->type(), Qt3DCore::PropertyValueAdded);
-            QCOMPARE(event->subjectId(), entity->id());
-            QCOMPARE(event->propertyName(), QByteArrayLiteral("children"));
-            QCOMPARE(event->addedNodeId(), comp->id());
-        }
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
     }
 }
 
@@ -1809,13 +1448,12 @@ void tst_Nodes::appendingParentlessComponentToEntityWithScene()
 void tst_Nodes::appendingComponentToEntity()
 {
     // GIVEN
-    ObserverSpy entitySpy;
-    ObserverSpy componentSpy;
+    TestArbiter arbiter;
     {
         QScopedPointer<MyQEntity> entity(new MyQEntity());
-        entity->setArbiterAndScene(&entitySpy);
+        entity->setArbiterAndScene(&arbiter);
         MyQComponent *comp = new MyQComponent(entity.data());
-        comp->setArbiter(&componentSpy);
+        comp->setArbiter(&arbiter);
         QCoreApplication::processEvents();
 
         // THEN
@@ -1831,28 +1469,20 @@ void tst_Nodes::appendingComponentToEntity()
         QVERIFY(entity->components().count() == 1);
         QVERIFY(entity->components().first() == comp);
         QVERIFY(comp->parentNode() == entity.data());
-        QCOMPARE(entitySpy.events.size(), 0);
-        QCOMPARE(entitySpy.dirtyNodes.size(), 1);
-        QCOMPARE(entitySpy.dirtySubNodes.size(), 1);
-        QCOMPARE(entitySpy.dirtyNodes.first(), entity.data());
-        const auto event = entitySpy.dirtySubNodes.takeFirst();
-        QCOMPARE(event.node, entity.data());
-        QCOMPARE(event.subNode, comp);
-        QCOMPARE(event.change, Qt3DCore::ComponentAdded);
-        QCOMPARE(event.property, nullptr);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().first(), entity.data());
     }
 }
 
 void tst_Nodes::removingComponentFromEntity()
 {
     // GIVEN
-    ObserverSpy entitySpy;
-    ObserverSpy componentSpy;
+    TestArbiter arbiter;
     {
         QScopedPointer<MyQEntity> entity(new MyQEntity());
-        entity->setArbiterAndScene(&entitySpy);
+        entity->setArbiterAndScene(&arbiter);
         MyQComponent *comp = new MyQComponent();
-        comp->setArbiter(&componentSpy);
+        comp->setArbiter(&arbiter);
 
         // WHEN
         entity->addComponent(comp);
@@ -1863,42 +1493,28 @@ void tst_Nodes::removingComponentFromEntity()
         QVERIFY(comp->parent() == entity.data());
 
         // WHEN
-        entitySpy.events.clear();
-        entitySpy.dirtyNodes.clear();
-        entitySpy.dirtySubNodes.clear();
-        componentSpy.events.clear();
+        arbiter.clear();
         entity->removeComponent(comp);
 
         // THEN
         QVERIFY(entity->components().count() == 0);
         QVERIFY(comp->parent() == entity.data());
         QVERIFY(entity->children().count() == 1);
-        QCOMPARE(entitySpy.events.size(), 0);
-        QCOMPARE(entitySpy.dirtyNodes.size(), 1);
-        QCOMPARE(entitySpy.dirtySubNodes.size(), 1);
-        QCOMPARE(componentSpy.events.size(), 0);
-        {
-            const auto event = entitySpy.dirtySubNodes.takeFirst();
-            qDebug() << event.change;
-            QCOMPARE(event.change, Qt3DCore::ComponentRemoved);
-            QCOMPARE(event.node, entity.data());
-            QCOMPARE(event.subNode, comp);
-            QCOMPARE(event.property, nullptr);
-        }
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
     }
 }
 
 void tst_Nodes::changeCustomProperty()
 {
     // GIVEN
-    ObserverSpy spy;
+    TestArbiter arbiter;
     QScopedPointer<MyQNode> node(new MyQNode());
-    node->setArbiterAndScene(&spy);
+    node->setArbiterAndScene(&arbiter);
     // WHEN
     node->setCustomProperty(QStringLiteral("foo"));
     // THEN
-    QCOMPARE(spy.dirtyNodes.size(), 1);
-    QCOMPARE(spy.dirtyNodes.front(), node.data());
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), node.data());
 }
 
 void tst_Nodes::checkDestruction()
@@ -2018,59 +1634,6 @@ void tst_Nodes::checkPropertyChanges()
     }
 }
 
-void tst_Nodes::checkCreationData()
-{
-    // GIVEN
-    Qt3DCore::QNode root;
-    Qt3DCore::QNode node;
-
-    node.setParent(&root);
-    node.setEnabled(true);
-    const QString enabledPropertyName = QStringLiteral("enabled");
-    node.setDefaultPropertyTrackingMode(Qt3DCore::QNode::DontTrackValues);
-    node.setPropertyTracking(enabledPropertyName, Qt3DCore::QNode::TrackAllValues);
-
-    // WHEN
-    QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-    {
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&node);
-        creationChanges = creationChangeGenerator.creationChanges();
-    }
-
-    // THEN
-    {
-        QCOMPARE(creationChanges.size(), 1);
-
-        const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChangeBase>(creationChanges.first());
-
-        QCOMPARE(node.id(), creationChangeData->subjectId());
-        QCOMPARE(node.isEnabled(), true);
-        QCOMPARE(node.isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(node.metaObject(), creationChangeData->metaObject());
-    }
-
-    // WHEN
-    node.setEnabled(false);
-
-    {
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&node);
-        creationChanges = creationChangeGenerator.creationChanges();
-    }
-
-    // THEN
-    {
-        QCOMPARE(creationChanges.size(), 1);
-
-        const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChangeBase>(creationChanges.first());
-
-        QCOMPARE(node.id(), creationChangeData->subjectId());
-        QCOMPARE(node.isEnabled(), false);
-        QCOMPARE(node.isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(node.metaObject(), creationChangeData->metaObject());
-    }
-}
-
 void tst_Nodes::checkEnabledUpdate()
 {
     // GIVEN
@@ -2083,11 +1646,10 @@ void tst_Nodes::checkEnabledUpdate()
         node.setEnabled(false);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), &node);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), &node);
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     {
@@ -2095,8 +1657,7 @@ void tst_Nodes::checkEnabledUpdate()
         node.setEnabled(false);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
     }
 
 }
@@ -2114,7 +1675,7 @@ void tst_Nodes::checkPropertyTrackModeUpdate()
         QCoreApplication::processEvents();
 
         // THEN -> this properties is non notifying
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
     }
 
     {
@@ -2123,7 +1684,7 @@ void tst_Nodes::checkPropertyTrackModeUpdate()
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
     }
 
 }
@@ -2141,7 +1702,7 @@ void tst_Nodes::checkTrackedPropertyNamesUpdate()
         QCoreApplication::processEvents();
 
         // THEN -> this properties is non notifying
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
     }
 
     {
@@ -2150,7 +1711,7 @@ void tst_Nodes::checkTrackedPropertyNamesUpdate()
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
     }
 
 }
@@ -2170,17 +1731,15 @@ void tst_Nodes::checkNodeRemovedFromDirtyListOnDestruction()
         node->setEnabled(false);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), node.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), node.data());
 
         // WHEN
         // scene should be unset and node removed from arbiter dirtyList
         node.reset();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
     }
     {
         // GIVEN
@@ -2196,17 +1755,16 @@ void tst_Nodes::checkNodeRemovedFromDirtyListOnDestruction()
         child->setEnabled(false);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1); // childAdded
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), child);
+        QCOMPARE(arbiter.dirtyNodes().size(), 2);
+        QCOMPARE(arbiter.dirtyNodes().at(0), node.data());
+        QCOMPARE(arbiter.dirtyNodes().at(1), child);
 
         // WHEN
         // scene should be unset and child node removed from arbiter dirtyList
         node.reset();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 1); // childRemoved (no destroyed change since we had no backend)
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
     }
 }
 
diff --git a/tests/auto/core/qarmature/tst_qarmature.cpp b/tests/auto/core/qarmature/tst_qarmature.cpp
index 098efd1af..a8199276c 100644
--- a/tests/auto/core/qarmature/tst_qarmature.cpp
+++ b/tests/auto/core/qarmature/tst_qarmature.cpp
@@ -33,9 +33,7 @@
 
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 using namespace Qt3DCore;
 
@@ -50,44 +48,6 @@ public:
 
 private Q_SLOTS:
 
-    void checkCreationChange_data()
-    {
-        QTest::addColumn<QArmature *>("armature");
-
-        QArmature *defaultConstructed = new QArmature();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        QArmature *armatureWithSkeleton = new QArmature();
-        armatureWithSkeleton->setSkeleton(new QSkeleton());
-        QTest::newRow("skeletonWithOneJoint") << armatureWithSkeleton;
-    }
-
-    void checkCreationChange()
-    {
-        // GIVEN
-        QFETCH(QArmature *, armature);
-
-        // WHEN
-        QNodeCreatedChangeGenerator creationChangeGenerator(armature);
-        QVector<QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        const int skeletonCount = armature->skeleton() ? 1 : 0;
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + skeletonCount);
-
-        const auto creationChangeData = qSharedPointerCast<QNodeCreatedChange<QArmatureData>>(creationChanges.first());
-        const QArmatureData &data = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(armature->id(), creationChangeData->subjectId());
-        QCOMPARE(armature->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(armature->metaObject(), creationChangeData->metaObject());
-        if (armature->skeleton()) {
-            QCOMPARE(armature->skeleton()->id(), data.skeletonId);
-        }
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -100,19 +60,19 @@ private Q_SLOTS:
         armature->setSkeleton(skeleton);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), armature.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), armature.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         armature->setSkeleton(nullptr);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), armature.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), armature.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkSkeletonBookkeeping()
diff --git a/tests/auto/core/qchangearbiter/qchangearbiter.pro b/tests/auto/core/qchangearbiter/qchangearbiter.pro
index 64a7b36e7..4628bf6cd 100644
--- a/tests/auto/core/qchangearbiter/qchangearbiter.pro
+++ b/tests/auto/core/qchangearbiter/qchangearbiter.pro
@@ -6,3 +6,5 @@ QT += testlib core core-private 3dcore 3dcore-private
 
 SOURCES += \
     tst_qchangearbiter.cpp
+
+include(../common/common.pri)
diff --git a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
index 3e9b24408..fc77b0343 100644
--- a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
+++ b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
@@ -26,22 +26,8 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
-#include <Qt3DCore/private/qobserverinterface_p.h>
-#include <Qt3DCore/private/qobservableinterface_p.h>
 #include <Qt3DCore/private/qchangearbiter_p.h>
-#include <Qt3DCore/private/qpostman_p.h>
-#include <Qt3DCore/qscenechange.h>
-#include <Qt3DCore/qcomponentaddedchange.h>
-#include <Qt3DCore/qcomponentremovedchange.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
-#include <Qt3DCore/qscenechange.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qnode.h>
 #include <Qt3DCore/qentity.h>
@@ -51,96 +37,16 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <QThread>
 #include <QWaitCondition>
+#include <testarbiter.h>
 
 class tst_QChangeArbiter : public QObject
 {
     Q_OBJECT
 
 private slots:
-    void registerObservers();
-    void registerSceneObserver();
-    void unregisterObservers();
-    void unregisterSceneObservers();
-    void distributeFrontendChanges();
-    void distributePropertyChanges();
-    void distributeBackendChanges();
-};
-
-class AllChangesChange : public Qt3DCore::QSceneChange
-{
-public:
-    AllChangesChange(Qt3DCore::QNodeId subjectId)
-        : Qt3DCore::QSceneChange(Qt3DCore::AllChanges, subjectId)
-    {
-    }
+    void recordsDirtyNodes();
 };
 
-class tst_Node : public Qt3DCore::QEntity
-{
-public:
-    explicit tst_Node(Qt3DCore::QNode *parent = 0) : Qt3DCore::QEntity(parent)
-    {}
-
-    void sendNodeAddedNotification(QNode *node)
-    {
-        Qt3DCore::QPropertyNodeAddedChangePtr e(new Qt3DCore::QPropertyNodeAddedChange(id(), node));
-        e->setPropertyName("PropertyValueAdded");
-        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
-    }
-
-    void sendNodeRemovedNotification(QNode *node)
-    {
-        Qt3DCore::QPropertyNodeRemovedChangePtr e(new Qt3DCore::QPropertyNodeRemovedChange(id(), node));
-        e->setPropertyName("PropertyValueRemoved");
-        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
-    }
-
-    void sendNodeUpdatedNotification()
-    {
-        Qt3DCore::QPropertyUpdatedChangePtr e(new Qt3DCore::QPropertyUpdatedChange(id()));
-        e->setPropertyName("PropertyUpdated");
-        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
-    }
-
-    void sendComponentAddedNotification(Qt3DCore::QComponent *component)
-    {
-        Qt3DCore::QComponentAddedChangePtr e(new Qt3DCore::QComponentAddedChange(this, component));
-        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
-    }
-
-    void sendComponentRemovedNotification(Qt3DCore::QComponent *component)
-    {
-        Qt3DCore::QComponentRemovedChangePtr e(new Qt3DCore::QComponentRemovedChange(this, component));
-        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
-    }
-
-    void sendAllChangesNotification()
-    {
-        Qt3DCore::QSceneChangePtr e(new AllChangesChange(id()));
-        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
-    }
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) override
-    {
-        QVERIFY(!change.isNull());
-        m_lastChanges << change;
-    }
-
-    Qt3DCore::QSceneChangePtr lastChange() const
-    {
-        if (m_lastChanges.isEmpty())
-            return Qt3DCore::QSceneChangePtr();
-        return m_lastChanges.last();
-    }
-
-    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
-    {
-        return m_lastChanges;
-    }
-
-private:
-    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
-};
 
 // used to test property change notifications
 class PropertyTestNode : public Qt3DCore::QNode
@@ -180,723 +86,53 @@ private:
     float m_prop2 = 0.0f;
 };
 
-class tst_SimpleObserver : public Qt3DCore::QObserverInterface
-{
-public:
-
-    // QObserverInterface interface
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override
-    {
-        QVERIFY(!e.isNull());
-        m_lastChanges.append(e);
-    }
-
-    Qt3DCore::QSceneChangePtr lastChange() const
-    {
-        if (m_lastChanges.isEmpty())
-            return Qt3DCore::QSceneChangePtr();
-        return m_lastChanges.last();
-    }
-
-    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
-    {
-        return m_lastChanges;
-    }
-
-    void clear()
-    {
-        m_lastChanges.clear();
-    }
-
-private:
-    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
-};
-
-class tst_BackendObserverObservable : public Qt3DCore::QBackendNode
-{
-public:
-
-    tst_BackendObserverObservable()
-        : Qt3DCore::QBackendNode(ReadWrite)
-    {}
-
-    // QObserverInterface interface
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) override
-    {
-        QVERIFY(!e.isNull());
-        m_lastChanges << e;
-        m_targetId = e->subjectId();
-    }
-
-    // should be called in thread
-    void sendReply()
-    {
-        Qt3DCore::QPropertyUpdatedChangePtr reply;
-        reply = QSharedPointer<Qt3DCore::QPropertyUpdatedChange>::create(m_targetId);
-        reply->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
-        reply->setPropertyName("Reply");
-        notifyObservers(reply);
-        qDebug() << Q_FUNC_INFO;
-    }
-
-    Qt3DCore::QSceneChangePtr lastChange() const
-    {
-        if (m_lastChanges.isEmpty())
-            return Qt3DCore::QSceneChangePtr();
-        return m_lastChanges.last();
-    }
-
-    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
-    {
-        return m_lastChanges;
-    }
-
-    void clear()
-    {
-        m_lastChanges.clear();
-    }
-
-private:
-    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
-    Qt3DCore::QNodeId m_targetId;
-
-};
-
-class ThreadedAnswer : public QThread
-{
-    Q_OBJECT
-public:
-    ThreadedAnswer(Qt3DCore::QChangeArbiter *arbiter, tst_BackendObserverObservable *backend)
-        : QThread()
-        , m_arbiter(arbiter)
-        , m_backendObs(backend)
-    {}
-
-    ~ThreadedAnswer() { qDebug() << this; }
-
-    void run() override
-    {
-        // create backend change queue on QChangeArbiter
-        Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(m_arbiter);
-        m_backendObs->sendReply();
-        // gives time for other threads to start waiting
-        QThread::currentThread()->sleep(1);
-        // wake waiting condition
-        m_waitingForReplyToBeSent.wakeOne();
-        exec();
-        Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(m_arbiter);
-    }
-
-    QWaitCondition *waitingCondition() { return &m_waitingForReplyToBeSent; }
-
-private:
-    Qt3DCore::QChangeArbiter *m_arbiter;
-    tst_BackendObserverObservable *m_backendObs;
-    QWaitCondition m_waitingForReplyToBeSent;
-};
-
-class tst_PostManObserver : public Qt3DCore::QAbstractPostman
-{
-public:
-
-    tst_PostManObserver()
-        : m_sceneInterface(nullptr)
-        , m_allowFrontendNotifications(false)
-    {}
-
-    void setScene(Qt3DCore::QScene *scene) final
-    {
-        m_sceneInterface = scene;
-    }
-
-    void setAllowFrontendNotifications(bool allow)
-    {
-        m_allowFrontendNotifications = allow;
-    }
-
-    // QObserverInterface interface
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-    {
-        QVERIFY(!e.isNull());
-        Qt3DCore::QPropertyUpdatedChangePtr change = qSharedPointerDynamicCast<Qt3DCore::QPropertyUpdatedChange>(e);
-        QVERIFY(!change.isNull());
-        Qt3DCore::QNode *targetNode = m_sceneInterface->lookupNode(change->subjectId());
-        QVERIFY(targetNode != nullptr);
-        m_lastChanges << e;
-    }
-
-    Qt3DCore::QSceneChangePtr lastChange() const
-    {
-        if (m_lastChanges.isEmpty())
-            return Qt3DCore::QSceneChangePtr();
-        return m_lastChanges.last();
-    }
-
-    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
-    {
-        return m_lastChanges;
-    }
-
-    void notifyBackend(const Qt3DCore::QSceneChangePtr &e) final
-    {
-        m_sceneInterface->arbiter()->sceneChangeEventWithLock(e);
-    }
-
-    bool shouldNotifyFrontend(const Qt3DCore::QSceneChangePtr &)
-    {
-        return m_allowFrontendNotifications;
-    }
-
-private:
-    Qt3DCore::QScene *m_sceneInterface;
-    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
-    bool m_allowFrontendNotifications;
-};
-
-void tst_QChangeArbiter::registerObservers()
+void tst_QChangeArbiter::recordsDirtyNodes()
 {
     // GIVEN
-    QScopedPointer<Qt3DCore::QChangeArbiter> arbiter(new Qt3DCore::QChangeArbiter());
+    QScopedPointer<TestArbiter> arbiter(new TestArbiter());
     QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene());
-    QScopedPointer<Qt3DCore::QAbstractPostman> postman(new tst_PostManObserver);
-    arbiter->setPostman(postman.data());
     arbiter->setScene(scene.data());
-    postman->setScene(scene.data());
     scene->setArbiter(arbiter.data());
-    // Replaces initialize as we have no JobManager in this case
-    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
 
     // WHEN
-    Qt3DCore::QNode *root = new tst_Node();
-    Qt3DCore::QNode *child = new tst_Node();
-    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
-    scene->addObservable(root);
+    auto *root = new PropertyTestNode();
+    auto *child = new PropertyTestNode(root);
 
-    QList<tst_SimpleObserver *> observers;
-    for (int i = 0; i < 5; i++) {
-        tst_SimpleObserver *s = new tst_SimpleObserver();
-        arbiter->registerObserver(s, root->id());
-        observers << s;
-    }
-
-    arbiter->syncChanges();
+    root->setProp1(883);
+    child->setProp2(1584);
 
     // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers))
-        QVERIFY(o->lastChange().isNull());
-
-    child->setParent(root);
-    arbiter->syncChanges();
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QCOMPARE(o->lastChanges().size(), 1);
-        QVERIFY(o->lastChanges().last()->type() == Qt3DCore::PropertyValueAdded);
-    }
-
-    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
-}
-
-void tst_QChangeArbiter::registerSceneObserver()
-{
-    // GIVEN
-    Qt3DCore::QComponent dummyComponent;
-    QScopedPointer<Qt3DCore::QChangeArbiter> arbiter(new Qt3DCore::QChangeArbiter());
-    QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene());
-    QScopedPointer<Qt3DCore::QAbstractPostman> postman(new tst_PostManObserver);
-    arbiter->setPostman(postman.data());
-    arbiter->setScene(scene.data());
-    postman->setScene(scene.data());
-    scene->setArbiter(arbiter.data());
-    // Replaces initialize as we have no JobManager in this case
-    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    QCOMPARE(arbiter->dirtyNodes().size(), 0);
 
     // WHEN
-    tst_Node *root = new tst_Node();
-    Qt3DCore::QNode *child = new tst_Node();
-    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
-    Qt3DCore::QNodePrivate::get(root)->m_hasBackendNode = true;
-    scene->addObservable(root);
-
-    QList<tst_SimpleObserver *> observers;
-    for (int i = 0; i < 5; i++) {
-        tst_SimpleObserver *s = new tst_SimpleObserver();
-        arbiter->registerObserver(s, root->id());
-        observers << s;
-    }
-
-    arbiter->syncChanges();
+    Qt3DCore::QNodePrivate::get(root)->setArbiter(arbiter.data());
+    root->setProp1(884);
+    child->setProp2(1585);
 
     // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers))
-        QVERIFY(o->lastChange().isNull());
+    QCOMPARE(arbiter->dirtyNodes().size(), 1);
+    QCOMPARE(arbiter->dirtyNodes().front(), root);
 
-    // WHEN
-    child->setParent(root);
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
-    }
+    arbiter->clear();
 
     // WHEN
-    root->sendComponentAddedNotification(&dummyComponent);
-    arbiter->syncChanges();
+    Qt3DCore::QNodePrivate::get(child)->setArbiter(arbiter.data());
+    child->setProp2(1586);
 
     // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::ComponentAdded);
-    }
+    QCOMPARE(arbiter->dirtyNodes().size(), 1);
+    QCOMPARE(arbiter->dirtyNodes().front(), child);
 
-    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
-}
-
-void tst_QChangeArbiter::unregisterObservers()
-{
-    // GIVEN
-    QScopedPointer<Qt3DCore::QChangeArbiter> arbiter(new Qt3DCore::QChangeArbiter());
-    QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene());
-    QScopedPointer<Qt3DCore::QAbstractPostman> postman(new tst_PostManObserver);
-    arbiter->setPostman(postman.data());
-    arbiter->setScene(scene.data());
-    postman->setScene(scene.data());
-    scene->setArbiter(arbiter.data());
-    // Replaces initialize as we have no JobManager in this case
-    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    arbiter->clear();
 
     // WHEN
-    tst_Node *root = new tst_Node();
-    Qt3DCore::QNode *child = new tst_Node();
-    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
-    scene->addObservable(root);
-
-    QList<tst_SimpleObserver *> observers;
-    for (int i = 0; i < 5; i++) {
-        tst_SimpleObserver *s = new tst_SimpleObserver();
-        arbiter->registerObserver(s, root->id());
-        observers << s;
-    }
-
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers))
-        QVERIFY(o->lastChange().isNull());
-
-    // WHEN
-    child->setParent(root);
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
-    }
-
-    // WHEN
-    for (tst_SimpleObserver *o : qAsConst(observers))
-        arbiter->unregisterObserver(o, root->id());
-
-    root->sendAllChangesNotification();
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
-    }
-
-    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
-}
-
-void tst_QChangeArbiter::unregisterSceneObservers()
-{
-    // GIVEN
-    Qt3DCore::QComponent dummyComponent;
-    QScopedPointer<Qt3DCore::QChangeArbiter> arbiter(new Qt3DCore::QChangeArbiter());
-    QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene());
-    QScopedPointer<Qt3DCore::QAbstractPostman> postman(new tst_PostManObserver);
-    arbiter->setPostman(postman.data());
-    arbiter->setScene(scene.data());
-    postman->setScene(scene.data());
-    scene->setArbiter(arbiter.data());
-    // Replaces initialize as we have no JobManager in this case
-    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
-
-    // WHEN
-    tst_Node *root = new tst_Node();
-    Qt3DCore::QNode *child = new tst_Node();
-    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
-    Qt3DCore::QNodePrivate::get(root)->m_hasBackendNode = true;
-    Qt3DCore::QNodePrivate::get(child)->m_hasBackendNode = true;
-    scene->addObservable(root);
-
-    QList<tst_SimpleObserver *> observers;
-    for (int i = 0; i < 5; i++) {
-        tst_SimpleObserver *s = new tst_SimpleObserver();
-        arbiter->registerObserver(s, root->id());
-        observers << s;
-    }
-
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers))
-        QVERIFY(o->lastChange().isNull());
-
-    // WHEN
-    child->setParent(root);
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
-    }
-
-    // WHEN
-    root->sendComponentAddedNotification(&dummyComponent);
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::ComponentAdded);
-    }
-
-    // WHEN
-    child->setParent(Q_NODE_NULLPTR);
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueRemoved);
-    }
-
-    // WHEN
-    child->setParent(root);
-    arbiter->syncChanges();
-
-    // THEN
-    for (tst_SimpleObserver *o : qAsConst(observers)) {
-        QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3DCore::PropertyValueAdded);
-    }
-
-    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
-}
-
-void tst_QChangeArbiter::distributeFrontendChanges()
-{
-    // GIVEN
-    Qt3DCore::QComponent dummyComponent;
-    Qt3DCore::QNode dummyNode;
-    QScopedPointer<Qt3DCore::QChangeArbiter> arbiter(new Qt3DCore::QChangeArbiter());
-    QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene());
-    QScopedPointer<Qt3DCore::QAbstractPostman> postman(new tst_PostManObserver);
-    arbiter->setPostman(postman.data());
-    arbiter->setScene(scene.data());
-    postman->setScene(scene.data());
-    scene->setArbiter(arbiter.data());
-    // Replaces initialize as we have no JobManager in this case
-    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
-
-    // WHEN
-    tst_Node *root = new tst_Node();
-    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
-    scene->addObservable(root);
-
-    tst_SimpleObserver *backendAllChangedObserver = new tst_SimpleObserver();
-    tst_SimpleObserver *backendNodeAddedObserver = new tst_SimpleObserver();
-    tst_SimpleObserver *backendNodeRemovedObserver = new tst_SimpleObserver();
-    tst_SimpleObserver *backendNodeUpdatedObserver = new tst_SimpleObserver();
-    tst_SimpleObserver *backendComponentAddedObserver = new tst_SimpleObserver();
-    tst_SimpleObserver *backendComponentRemovedObserver = new tst_SimpleObserver();
-
-    arbiter->registerObserver(backendAllChangedObserver, root->id());
-    arbiter->registerObserver(backendNodeAddedObserver, root->id(), Qt3DCore::PropertyValueAdded);
-    arbiter->registerObserver(backendNodeUpdatedObserver, root->id(), Qt3DCore::PropertyUpdated);
-    arbiter->registerObserver(backendNodeRemovedObserver, root->id(), Qt3DCore::PropertyValueRemoved);
-    arbiter->registerObserver(backendComponentAddedObserver, root->id(), Qt3DCore::ComponentAdded);
-    arbiter->registerObserver(backendComponentRemovedObserver, root->id(), Qt3DCore::ComponentRemoved);
-
-    arbiter->syncChanges();
-
-    // THEN
-    QVERIFY(backendAllChangedObserver->lastChange().isNull());
-    QVERIFY(backendNodeAddedObserver->lastChange().isNull());
-    QVERIFY(backendNodeUpdatedObserver->lastChange().isNull());
-    QVERIFY(backendNodeRemovedObserver->lastChange().isNull());
-    QVERIFY(backendComponentAddedObserver->lastChange().isNull());
-    QVERIFY(backendComponentRemovedObserver->lastChange().isNull());
-
-    // WHEN
-    root->sendNodeAddedNotification(&dummyNode);
-    arbiter->syncChanges();
-
-    // THEN
-    QCOMPARE(backendAllChangedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeAddedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeUpdatedObserver->lastChanges().count(), 0);
-    QCOMPARE(backendNodeRemovedObserver->lastChanges().count(), 0);
-    QCOMPARE(backendComponentAddedObserver->lastChanges().count(), 0);
-    QCOMPARE(backendComponentRemovedObserver->lastChanges().count(), 0);
-
-    // WHEN
-    root->sendNodeUpdatedNotification();
-    arbiter->syncChanges();
-
-    // THEN
-    QCOMPARE(backendAllChangedObserver->lastChanges().count(), 2);
-    QCOMPARE(backendNodeAddedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeUpdatedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeRemovedObserver->lastChanges().count(), 0);
-    QCOMPARE(backendComponentAddedObserver->lastChanges().count(), 0);
-    QCOMPARE(backendComponentRemovedObserver->lastChanges().count(), 0);
-
-    // WHEN
-    root->sendNodeRemovedNotification(&dummyNode);
-    arbiter->syncChanges();
-
-    // THEN
-    QCOMPARE(backendAllChangedObserver->lastChanges().count(), 3);
-    QCOMPARE(backendNodeAddedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeUpdatedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeRemovedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendComponentAddedObserver->lastChanges().count(), 0);
-    QCOMPARE(backendComponentRemovedObserver->lastChanges().count(), 0);
-
-    // WHEN
-    root->sendComponentAddedNotification(&dummyComponent);
-    arbiter->syncChanges();
-
-    // THEN
-    QCOMPARE(backendAllChangedObserver->lastChanges().count(), 4);
-    QCOMPARE(backendNodeAddedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeUpdatedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeRemovedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendComponentAddedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendComponentRemovedObserver->lastChanges().count(), 0);
-
-    // WHEN
-    root->sendComponentRemovedNotification(&dummyComponent);
-    arbiter->syncChanges();
-
-    // THEN
-    QCOMPARE(backendAllChangedObserver->lastChanges().count(), 5);
-    QCOMPARE(backendNodeAddedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeUpdatedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendNodeRemovedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendComponentAddedObserver->lastChanges().count(), 1);
-    QCOMPARE(backendComponentRemovedObserver->lastChanges().count(), 1);
-
-    // WHEN
-    root->sendAllChangesNotification();
-    arbiter->syncChanges();
-
-    // THEN
-    QCOMPARE(backendAllChangedObserver->lastChanges().count(), 6);
-    QCOMPARE(backendNodeAddedObserver->lastChanges().count(), 2);
-    QCOMPARE(backendNodeUpdatedObserver->lastChanges().count(), 2);
-    QCOMPARE(backendNodeRemovedObserver->lastChanges().count(), 2);
-    QCOMPARE(backendComponentAddedObserver->lastChanges().count(), 2);
-    QCOMPARE(backendComponentRemovedObserver->lastChanges().count(), 2);
-
-    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
-}
-
-void tst_QChangeArbiter::distributePropertyChanges()
-{
-    // GIVEN
-    QScopedPointer<Qt3DCore::QChangeArbiter> arbiter(new Qt3DCore::QChangeArbiter());
-    QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene());
-    QScopedPointer<Qt3DCore::QAbstractPostman> postman(new tst_PostManObserver);
-    arbiter->setPostman(postman.data());
-    arbiter->setScene(scene.data());
-    postman->setScene(scene.data());
-    scene->setArbiter(arbiter.data());
-    // Replaces initialize as we have no JobManager in this case
-    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
-
-    // Test change notifications made to the root node:
-
-    // WHEN
-    PropertyTestNode *root = new PropertyTestNode();
-    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
-    Qt3DCore::QNodePrivate::get(root)->m_hasBackendNode = true;
-    scene->addObservable(root);
-
-    tst_SimpleObserver *rootObserver = new tst_SimpleObserver();
-    arbiter->registerObserver(rootObserver, root->id());
-    arbiter->syncChanges();
-
-    // THEN
-    QVERIFY(rootObserver->lastChange().isNull());
-
-    // WHEN
-    root->setProp1(root->prop1() + 1);
-
-    // THEN
-    auto dirtyNodes = arbiter->takeDirtyFrontEndNodes();
-    QCOMPARE(dirtyNodes.size(), 1);
-    QCOMPARE(dirtyNodes.front(), root);
-
-    // WHEN
-    root->setProp2(root->prop2() + 1.f);
-
-    // THEN
-    dirtyNodes = arbiter->takeDirtyFrontEndNodes();
-    QCOMPARE(dirtyNodes.size(), 1);
-    QCOMPARE(dirtyNodes.front(), root);
-
-    // Test change notifications made to an entity that was added to the scene
-    // via QNode::setParent()
-
-    // WHEN
-    PropertyTestNode *setParentChild = new PropertyTestNode();
-    setParentChild->setParent(root);
-    tst_SimpleObserver *setParentChildObserver = new tst_SimpleObserver();
-    arbiter->registerObserver(setParentChildObserver, setParentChild->id());
-    setParentChild->setProp2(setParentChild->prop2() + 1.f);
-
-    // THEN
-    dirtyNodes = arbiter->takeDirtyFrontEndNodes();
-    QCOMPARE(dirtyNodes.size(), 1);
-    QCOMPARE(dirtyNodes.front(), setParentChild);
-
-    // Test change notifications made to an entity that was added to the scene
-    // via the QNode() constructor parent parameter
-
-    // WHEN
-    PropertyTestNode *directChild = new PropertyTestNode(root);
-    QCoreApplication::processEvents();  // make sure the post-ctor initialization is executed for the node
-    tst_SimpleObserver *directChildObserver = new tst_SimpleObserver();
-    arbiter->registerObserver(directChildObserver, directChild->id());
-    directChild->setProp1(directChild->prop1() + 1);
+    root->setProp1(887);
+    child->setProp2(1587);
 
     // THEN
-    dirtyNodes = arbiter->takeDirtyFrontEndNodes();
-    QCOMPARE(dirtyNodes.size(), 1);
-    QCOMPARE(dirtyNodes.front(), directChild);
-
-    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
+    QCOMPARE(arbiter->dirtyNodes().size(), 2);
 }
 
-void tst_QChangeArbiter::distributeBackendChanges()
-{
-
-    // GIVEN
-    QScopedPointer<Qt3DCore::QChangeArbiter> arbiter(new Qt3DCore::QChangeArbiter());
-    QScopedPointer<Qt3DCore::QScene> scene(new Qt3DCore::QScene());
-    QScopedPointer<tst_PostManObserver> postman(new tst_PostManObserver);
-    arbiter->setPostman(postman.data());
-    arbiter->setScene(scene.data());
-    postman->setScene(scene.data());
-    scene->setArbiter(arbiter.data());
-    // Replaces initialize as we have no JobManager in this case
-    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
-
-    // In order for backend -> frontend changes to work properly,
-    // the backend notification should only be sent
-    // from a worker thread which has a dedicated ChangeQueue in the
-    // ChangeArbiter different than the frontend ChangeQueue. In this
-    // test we will only check that the backend has received the frontend notification
-
-
-    // WHEN
-    tst_Node *root = new tst_Node();
-    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
-    Qt3DCore::QNodePrivate::get(root)->m_hasBackendNode = true;
-    scene->addObservable(root);
-
-    tst_BackendObserverObservable *backenObserverObservable = new tst_BackendObserverObservable();
-    arbiter->registerObserver(Qt3DCore::QBackendNodePrivate::get(backenObserverObservable), root->id());
-    arbiter->scene()->addObservable(Qt3DCore::QBackendNodePrivate::get(backenObserverObservable), root->id());
-    Qt3DCore::QBackendNodePrivate::get(backenObserverObservable)->setArbiter(arbiter.data());
-
-    arbiter->syncChanges();
-
-    // THEN
-    QVERIFY(root->lastChange().isNull());
-    QVERIFY(backenObserverObservable->lastChange().isNull());
-    QCOMPARE(backenObserverObservable->lastChanges().count(), 0);
-
-    // WHEN
-    root->sendAllChangesNotification();
-    arbiter->syncChanges();
-
-    // THEN
-    // backend observer receives event from frontend node "root"
-    QCOMPARE(root->lastChanges().count(), 0);
-    QCOMPARE(postman->lastChanges().count(), 0);
-    QCOMPARE(backenObserverObservable->lastChanges().count(), 1);
-
-    backenObserverObservable->clear();
-
-    {
-        // WHEN
-        // simulate a worker thread
-        QScopedPointer<ThreadedAnswer> answer(new ThreadedAnswer(arbiter.data(), backenObserverObservable));
-        postman->setAllowFrontendNotifications(false);
-        QWaitCondition *waitingForBackendReplyCondition = answer->waitingCondition();
-
-        QMutex mutex;
-        // sends reply from another thread (simulates job thread)
-        answer->start();
-        mutex.lock();
-        waitingForBackendReplyCondition->wait(&mutex);
-        mutex.unlock();
-
-        // To verify that backendObserver sent a reply
-        arbiter->syncChanges();
-
-        // THEN
-        // the repliers should receive it's reply
-        QCOMPARE(backenObserverObservable->lastChanges().count(), 1);
-        // verify that postMan has received the change
-        QCOMPARE(postman->lastChanges().count(), 0);
-        answer->exit();
-        answer->wait();
-        backenObserverObservable->clear();
-    }
-
-    {
-        // WHEN
-        // simulate a worker thread
-        QScopedPointer<ThreadedAnswer> answer(new ThreadedAnswer(arbiter.data(), backenObserverObservable));
-        postman->setAllowFrontendNotifications(true);
-        QWaitCondition *waitingForBackendReplyCondition = answer->waitingCondition();
-        QMutex mutex;
-        // sends reply from another thread (simulates job thread)
-        answer->start();
-        mutex.lock();
-        waitingForBackendReplyCondition->wait(&mutex);
-        mutex.unlock();
-
-        // To verify that backendObserver sent a reply
-        arbiter->syncChanges();
-
-        // THEN
-        // the repliers should receive it's reply
-        QCOMPARE(backenObserverObservable->lastChanges().count(), 1);
-        // verify that postMan has received the change
-        QCOMPARE(postman->lastChanges().count(), 1);
-
-        // verify correctness of the reply
-        Qt3DCore::QPropertyUpdatedChangePtr c = qSharedPointerDynamicCast<Qt3DCore::QPropertyUpdatedChange>(postman->lastChange());
-        QVERIFY(!c.isNull());
-        QVERIFY(c->subjectId() == root->id());
-        qDebug() << c->propertyName();
-        QVERIFY(strcmp(c->propertyName(), "Reply") == 0);
-        QVERIFY(c->type() == Qt3DCore::PropertyUpdated);
-        answer->exit();
-        answer->wait();
-    }
-
-    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
-}
 
 QTEST_MAIN(tst_QChangeArbiter)
 
diff --git a/tests/auto/core/qentity/tst_qentity.cpp b/tests/auto/core/qentity/tst_qentity.cpp
index 7b41c9783..4b32c5aac 100644
--- a/tests/auto/core/qentity/tst_qentity.cpp
+++ b/tests/auto/core/qentity/tst_qentity.cpp
@@ -26,14 +26,9 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QtTest>
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/private/qentity_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/qcomponent.h>
 #include <QtCore/qscopedpointer.h>
 
@@ -67,9 +62,6 @@ private slots:
     void addSeveralTimesSameComponent();
     void removeSeveralTimesSameComponent();
 
-    void checkCloning_data();
-    void checkCloning();
-
     void checkComponentBookkeeping();
 };
 
@@ -590,81 +582,6 @@ void tst_Entity::removeSeveralTimesSameComponent()
     QCOMPARE(comp->entities().size(), 0);
 }
 
-void tst_Entity::checkCloning_data()
-{
-    QTest::addColumn<Qt3DCore::QEntity *>("entity");
-    QTest::addColumn<QVector<QNodeId>>("childEntityIds");
-    QTest::addColumn<int>("creationChangeCount");
-
-    {
-        QTest::newRow("defaultConstructed") << new MyEntity() << QVector<QNodeId>() << 1;
-    }
-
-    {
-        Qt3DCore::QEntity *entityWithComponents = new MyEntity();
-        Qt3DCore::QComponent *component1 = new MyQComponent();
-        Qt3DCore::QComponent *component2 = new MyQComponent();
-        Qt3DCore::QComponent *component3 = new MyQComponent();
-        entityWithComponents->addComponent(component1);
-        entityWithComponents->addComponent(component2);
-        entityWithComponents->addComponent(component3);
-        QTest::newRow("entityWithComponents") << entityWithComponents << QVector<QNodeId>() << 4;
-    }
-
-    {
-        Qt3DCore::QEntity *entityWithChildren = new MyEntity();
-        Qt3DCore::QEntity *child1 = new MyEntity(entityWithChildren);
-        Qt3DCore::QEntity *child2 = new MyEntity(entityWithChildren);
-        QVector<QNodeId> childIds = {child1->id(), child2->id()};
-        QTest::newRow("entityWithChildren") << entityWithChildren << childIds << 3;
-    }
-
-    {
-        Qt3DCore::QEntity *entityWithNestedChildren = new MyEntity();
-        Qt3DCore::QEntity *child = new MyEntity(entityWithNestedChildren);
-        Qt3DCore::QNode *dummy = new Qt3DCore::QNode(entityWithNestedChildren);
-        Qt3DCore::QEntity *grandChild = new MyEntity(entityWithNestedChildren);
-        QVector<QNodeId> childIds = {child->id(), grandChild->id()};
-        QTest::newRow("entityWithNestedChildren") << entityWithNestedChildren << childIds << 4;
-
-        Q_UNUSED(dummy);
-    }
-}
-
-void tst_Entity::checkCloning()
-{
-    // GIVEN
-    QFETCH(Qt3DCore::QEntity *, entity);
-    QFETCH(QVector<QNodeId>, childEntityIds);
-    QFETCH(int, creationChangeCount);
-
-    // WHEN
-    Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(entity);
-    QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-    // THEN
-    QCOMPARE(creationChanges.size(), creationChangeCount);
-
-    const Qt3DCore::QNodeCreatedChangePtr<Qt3DCore::QEntityData> creationChangeData =
-            qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DCore::QEntityData>>(creationChanges.first());
-    const Qt3DCore::QEntityData &cloneData = creationChangeData->data;
-
-    // THEN
-    QCOMPARE(creationChangeData->subjectId(), entity->id());
-    QCOMPARE(creationChangeData->isNodeEnabled(), entity->isEnabled());
-    QCOMPARE(creationChangeData->metaObject(), entity->metaObject());
-    QCOMPARE(creationChangeData->parentId(), entity->parentNode() ? entity->parentNode()->id() : Qt3DCore::QNodeId());
-    QCOMPARE(cloneData.parentEntityId, entity->parentEntity() ? entity->parentEntity()->id() : Qt3DCore::QNodeId());
-    QCOMPARE(cloneData.childEntityIds, childEntityIds);
-    QCOMPARE(cloneData.componentIdsAndTypes.size(), entity->components().size());
-
-    const QVector<Qt3DCore::QComponent *> &components = entity->components();
-    for (int i = 0, m = components.size(); i < m; ++i) {
-        QCOMPARE(cloneData.componentIdsAndTypes.at(i).id, components.at(i)->id());
-        QCOMPARE(cloneData.componentIdsAndTypes.at(i).type, components.at(i)->metaObject());
-    }
-}
-
 void tst_Entity::checkComponentBookkeeping()
 {
     // GIVEN
diff --git a/tests/auto/core/qjoint/tst_qjoint.cpp b/tests/auto/core/qjoint/tst_qjoint.cpp
index 2fff33b8f..6f72dc7af 100644
--- a/tests/auto/core/qjoint/tst_qjoint.cpp
+++ b/tests/auto/core/qjoint/tst_qjoint.cpp
@@ -29,11 +29,9 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/qjoint.h>
 #include <Qt3DCore/private/qjoint_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 using namespace Qt3DCore;
 
@@ -241,71 +239,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        QJoint joint;
-
-        joint.setScale(QVector3D(3.5f, 2.0f, 1.3f));
-        joint.setRotation(QQuaternion::fromAxisAndAngle(0.0f, 1.0f, 0.0f, 30.0f));
-        joint.setTranslation(QVector3D(3.0f, 2.0f, 1.0f));
-        QMatrix4x4 ibm;
-        ibm.scale(5.2f);
-        joint.setInverseBindMatrix(ibm);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&joint);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData
-                = qSharedPointerCast<QNodeCreatedChange<QJointData>>(creationChanges.first());
-            const QJointData data = creationChangeData->data;
-
-            QCOMPARE(joint.id(), creationChangeData->subjectId());
-            QCOMPARE(joint.isEnabled(), true);
-            QCOMPARE(joint.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(joint.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(joint.scale(), data.scale);
-            QCOMPARE(joint.rotation(), data.rotation);
-            QCOMPARE(joint.translation(), data.translation);
-            QCOMPARE(joint.inverseBindMatrix(), data.inverseBindMatrix);
-        }
-
-        // WHEN
-        joint.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&joint);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData
-                = qSharedPointerCast<QNodeCreatedChange<QJointData>>(creationChanges.first());
-            const QJointData data = creationChangeData->data;
-
-            QCOMPARE(joint.id(), creationChangeData->subjectId());
-            QCOMPARE(joint.isEnabled(), false);
-            QCOMPARE(joint.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(joint.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(joint.scale(), data.scale);
-            QCOMPARE(joint.rotation(), data.rotation);
-            QCOMPARE(joint.translation(), data.translation);
-            QCOMPARE(joint.inverseBindMatrix(), data.inverseBindMatrix);
-        }
-    }
-
     void checkPropertyUpdateChanges()
     {
         // GIVEN
@@ -318,16 +251,16 @@ private Q_SLOTS:
             joint.setScale(QVector3D(2.0f, 1.0f, 3.0f));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &joint);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             joint.setScale(QVector3D(2.0f, 1.0f, 3.0f));
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -336,16 +269,16 @@ private Q_SLOTS:
             joint.setRotation(newValue);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &joint);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             joint.setRotation(newValue);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -354,16 +287,16 @@ private Q_SLOTS:
             joint.setTranslation(newValue);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &joint);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             joint.setTranslation(newValue);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -373,16 +306,16 @@ private Q_SLOTS:
             joint.setInverseBindMatrix(newValue);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &joint);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &joint);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             joint.setInverseBindMatrix(newValue);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 };
diff --git a/tests/auto/core/qpostman/qpostman.pro b/tests/auto/core/qpostman/qpostman.pro
deleted file mode 100644
index fee342f74..000000000
--- a/tests/auto/core/qpostman/qpostman.pro
+++ /dev/null
@@ -1,11 +0,0 @@
-TEMPLATE = app
-
-TARGET = tst_qpostman
-
-QT += 3dcore 3dcore-private 3drender 3drender-private testlib
-
-CONFIG += testcase
-
-SOURCES += tst_qpostman.cpp
-
-include(../common/common.pri)
diff --git a/tests/auto/core/qpostman/tst_qpostman.cpp b/tests/auto/core/qpostman/tst_qpostman.cpp
deleted file mode 100644
index d0dfa0f49..000000000
--- a/tests/auto/core/qpostman/tst_qpostman.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-
-#include <QtTest/QTest>
-#include <Qt3DCore/private/qpostman_p.h>
-#include <Qt3DCore/private/qpostman_p_p.h>
-#include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
-#include <Qt3DCore/private/qnode_p.h>
-#include <Qt3DCore/private/qpropertyupdatedchangebase_p.h>
-#include "testpostmanarbiter.h"
-
-using namespace Qt3DCore;
-
-namespace {
-
-class NodeChangeReceiver: public QNode
-{
-public:
-    NodeChangeReceiver(QNode *parent = nullptr)
-        : QNode(parent)
-        , m_hasReceivedChange(false)
-    {}
-
-    inline bool hasReceivedChange() const { return m_hasReceivedChange; }
-
-protected:
-    void sceneChangeEvent(const QSceneChangePtr &) override
-    {
-        m_hasReceivedChange = true;
-    }
-
-private:
-    bool m_hasReceivedChange;
-};
-
-} // anonymous
-
-class tst_QPostman : public QObject
-{
-    Q_OBJECT
-
-private Q_SLOTS:
-
-    void checkSetScene()
-    {
-        // GIVEN
-        QPostman postman;
-
-        // THEN
-        QVERIFY(QPostmanPrivate::get(&postman)->m_scene == nullptr);
-
-        // WHEN
-        QScene scene;
-        postman.setScene(&scene);
-
-        // THEN
-        QCOMPARE(QPostmanPrivate::get(&postman)->m_scene, &scene);
-    }
-
-};
-
-QTEST_MAIN(tst_QPostman)
-
-#include "tst_qpostman.moc"
diff --git a/tests/auto/core/qscene/tst_qscene.cpp b/tests/auto/core/qscene/tst_qscene.cpp
index eb6a8c5ec..5a23dab48 100644
--- a/tests/auto/core/qscene/tst_qscene.cpp
+++ b/tests/auto/core/qscene/tst_qscene.cpp
@@ -26,19 +26,13 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QtTest>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qnode.h>
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qcomponent.h>
-#include <Qt3DCore/private/qobservableinterface_p.h>
-#include <Qt3DCore/private/qlockableobserverinterface_p.h>
 #include <private/qnode_p.h>
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_QScene : public QObject
 {
@@ -48,9 +42,7 @@ public:
     ~tst_QScene() {}
 
 private slots:
-    void addObservable();
     void addNodeObservable();
-    void removeObservable();
     void removeNodeObservable();
     void addChildNode();
     void deleteChildNode();
@@ -65,21 +57,6 @@ private slots:
     void nodeUpdatePropertyTrackData();
 };
 
-class tst_Observable : public Qt3DCore::QObservableInterface
-{
-public:
-    void setArbiter(Qt3DCore::QLockableObserverInterface *observer)
-    {
-        m_arbiter = observer;
-    }
-
-protected:
-    void notifyObservers(const Qt3DCore::QSceneChangePtr &) {}
-
-private:
-    Qt3DCore::QLockableObserverInterface *m_arbiter;
-};
-
 class tst_Node : public Qt3DCore::QNode
 {
     Q_OBJECT
@@ -96,44 +73,6 @@ public:
     {}
 };
 
-void tst_QScene::addObservable()
-{
-    // GIVEN
-    Qt3DCore::QNode *node1 = new tst_Node();
-    Qt3DCore::QNode *node2 = new tst_Node();
-
-    QList<tst_Observable *> observables;
-
-    for (int i = 0; i < 10; i++)
-        observables.append(new tst_Observable());
-
-    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
-    scene->setArbiter(new TestArbiter);
-
-    // WHEN
-    for (int i = 0; i < 5; i++)
-        scene->addObservable(observables.at(i), node1->id());
-
-    for (int i = 0; i < 5; i++)
-        scene->addObservable(observables.at(i + 5), node2->id());
-
-    const Qt3DCore::QObservableList obs1 = scene->lookupObservables(node1->id());
-    const Qt3DCore::QObservableList obs2 = scene->lookupObservables(node2->id());
-
-    // THEN
-    QCOMPARE(obs1.count(), 5);
-    QCOMPARE(obs2.count(), obs1.count());
-
-    for (Qt3DCore::QObservableInterface *o : obs1) {
-        QVERIFY(scene->nodeIdFromObservable(o) == node1->id());
-        QVERIFY(scene->lookupNode(node1->id()) == nullptr);
-    }
-    for (Qt3DCore::QObservableInterface *o : obs2) {
-        QVERIFY(scene->nodeIdFromObservable(o) == node2->id());
-        QVERIFY(scene->lookupNode(node2->id()) == nullptr);
-    }
-}
-
 void tst_QScene::addNodeObservable()
 {
     // GIBEN
@@ -152,72 +91,15 @@ void tst_QScene::addNodeObservable()
     // THEN
     for (Qt3DCore::QNode *n : qAsConst(nodes)) {
         QVERIFY(n == scene->lookupNode(n->id()));
-        QVERIFY(scene->lookupObservables(n->id()).isEmpty());
     }
 }
 
-void tst_QScene::removeObservable()
-{
-    // GIVEN
-    Qt3DCore::QNode *node1 = new tst_Node();
-    Qt3DCore::QNode *node2 = new tst_Node();
-
-    QList<tst_Observable *> observables;
-
-    for (int i = 0; i < 10; i++)
-        observables.append(new tst_Observable());
-
-    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
-    scene->setArbiter(new TestArbiter);
-
-    // WHEN
-    for (int i = 0; i < 5; i++)
-        scene->addObservable(observables.at(i), node1->id());
-
-    for (int i = 0; i < 5; i++)
-        scene->addObservable(observables.at(i + 5), node2->id());
-
-    Qt3DCore::QObservableList obs1 = scene->lookupObservables(node1->id());
-    Qt3DCore::QObservableList obs2 = scene->lookupObservables(node2->id());
-
-    // THEN
-    QCOMPARE(obs1.count(), 5);
-    QCOMPARE(obs2.count(), obs1.count());
-
-    // WHEN
-    scene->removeObservable(observables.at(0), node1->id());
-    // THEN
-    QCOMPARE(scene->lookupObservables(node1->id()).count(), 4);
-
-    // WHEN
-    scene->removeObservable(observables.at(0), node1->id());
-    // THEN
-    QCOMPARE(scene->lookupObservables(node1->id()).count(), 4);
-
-    // WHEN
-    scene->removeObservable(observables.at(6), node1->id());
-    // THEN
-    QCOMPARE(scene->lookupObservables(node1->id()).count(), 4);
-    QCOMPARE(scene->lookupObservables(node2->id()).count(), 5);
-
-    // WHEN
-    scene->removeObservable(observables.at(0), node2->id());
-    // THEN
-    QCOMPARE(scene->lookupObservables(node2->id()).count(), 5);
-    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3DCore::QNodeId());
-}
-
 void tst_QScene::removeNodeObservable()
 {
     // GIVEN
     Qt3DCore::QNode *node1 = new tst_Node();
     Qt3DCore::QNode *node2 = new tst_Node();
 
-    QList<tst_Observable *> observables;
-
-    for (int i = 0; i < 10; i++)
-        observables.append(new tst_Observable());
-
     Qt3DCore::QScene *scene = new Qt3DCore::QScene;
     scene->setArbiter(new TestArbiter);
 
@@ -225,30 +107,12 @@ void tst_QScene::removeNodeObservable()
     scene->addObservable(node1);
     scene->addObservable(node2);
 
-    for (int i = 0; i < 5; i++)
-        scene->addObservable(observables.at(i), node1->id());
-
-    for (int i = 0; i < 5; i++)
-        scene->addObservable(observables.at(i + 5), node2->id());
-
-    // THEN
-    Qt3DCore::QObservableList obs1 = scene->lookupObservables(node1->id());
-    Qt3DCore::QObservableList obs2 = scene->lookupObservables(node2->id());
-
-    QCOMPARE(obs1.count(), 5);
-    QCOMPARE(obs2.count(), obs1.count());
-
     // WHEN
     scene->removeObservable(node1);
 
     // THEN
     QVERIFY(scene->lookupNode(node1->id()) == nullptr);
-    QVERIFY(scene->lookupObservables(node1->id()).empty());
-    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3DCore::QNodeId());
-
     QVERIFY(scene->lookupNode(node2->id()) == node2);
-    QCOMPARE(scene->lookupObservables(node2->id()).count(), 5);
-    QVERIFY(scene->nodeIdFromObservable(observables.at(9)) == node2->id());
 }
 
 void tst_QScene::addChildNode()
diff --git a/tests/auto/core/qskeleton/tst_qskeleton.cpp b/tests/auto/core/qskeleton/tst_qskeleton.cpp
index 5c88bd754..151b2d1bf 100644
--- a/tests/auto/core/qskeleton/tst_qskeleton.cpp
+++ b/tests/auto/core/qskeleton/tst_qskeleton.cpp
@@ -33,10 +33,9 @@
 
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 using namespace Qt3DCore;
 
@@ -59,44 +58,6 @@ private Q_SLOTS:
         QCOMPARE(skeleton.jointCount(), 0);
     }
 
-    void checkCreationChange_data()
-    {
-        QTest::addColumn<QSkeleton *>("skeleton");
-
-        QSkeleton *defaultConstructed = new QSkeleton();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        QSkeleton *skeletonWithOneJoint = new QSkeleton();
-        skeletonWithOneJoint->setRootJoint(new QJoint());
-        QTest::newRow("skeletonWithOneJoint") << skeletonWithOneJoint;
-    }
-
-    void checkCreationChange()
-    {
-        // GIVEN
-        QFETCH(QSkeleton *, skeleton);
-
-        // WHEN
-        QNodeCreatedChangeGenerator creationChangeGenerator(skeleton);
-        QVector<QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        const int jointCount = skeleton->rootJoint() ? 1 : 0;
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + jointCount);
-
-        const auto creationChangeData = qSharedPointerCast<QNodeCreatedChange<QSkeletonData>>(creationChanges.first());
-        const QSkeletonData &data = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(skeleton->id(), creationChangeData->subjectId());
-        QCOMPARE(skeleton->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(skeleton->metaObject(), creationChangeData->metaObject());
-        if (skeleton->rootJoint()) {
-            QCOMPARE(skeleton->rootJoint()->id(), data.rootJointId);
-        }
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -106,24 +67,24 @@ private Q_SLOTS:
 
         // WHEN
         QJoint *joint = new QJoint(skeleton.data());
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         skeleton->setRootJoint(joint);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), skeleton.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), skeleton.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         skeleton->setRootJoint(nullptr);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), skeleton.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), skeleton.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkRootJointBookkeeping()
diff --git a/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp b/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp
index f0f4c3872..0b01831a9 100644
--- a/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp
+++ b/tests/auto/core/qskeletonloader/tst_qskeletonloader.cpp
@@ -31,12 +31,9 @@
 #include <Qt3DCore/qskeletonloader.h>
 #include <Qt3DCore/qjoint.h>
 #include <Qt3DCore/private/qskeletonloader_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 using namespace Qt3DCore;
 
@@ -102,60 +99,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        QSkeletonLoader skeleton;
-
-        skeleton.setSource(QUrl(QStringLiteral("http://someRemoteURL.com/dem-bones.skel")));
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            QNodeCreatedChangeGenerator creationChangeGenerator(&skeleton);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<QNodeCreatedChange<QSkeletonLoaderData>>(creationChanges.first());
-            const QSkeletonLoaderData data = creationChangeData->data;
-
-            QCOMPARE(skeleton.id(), creationChangeData->subjectId());
-            QCOMPARE(skeleton.isEnabled(), true);
-            QCOMPARE(skeleton.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(skeleton.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(skeleton.source(), data.source);
-            QCOMPARE(skeleton.isCreateJointsEnabled(), data.createJoints);
-        }
-
-        // WHEN
-        skeleton.setEnabled(false);
-
-        {
-            QNodeCreatedChangeGenerator creationChangeGenerator(&skeleton);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<QNodeCreatedChange<QSkeletonLoaderData>>(creationChanges.first());
-            const QSkeletonLoaderData data = creationChangeData->data;
-
-            QCOMPARE(skeleton.id(), creationChangeData->subjectId());
-            QCOMPARE(skeleton.isEnabled(), false);
-            QCOMPARE(skeleton.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(skeleton.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(skeleton.source(), data.source);
-            QCOMPARE(skeleton.isCreateJointsEnabled(), data.createJoints);
-        }
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -169,11 +112,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes[0], &skeleton);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes()[0], &skeleton);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -182,8 +124,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         {
@@ -192,11 +133,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes[0], &skeleton);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes()[0], &skeleton);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -205,8 +145,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 };
diff --git a/tests/auto/core/qtransform/tst_qtransform.cpp b/tests/auto/core/qtransform/tst_qtransform.cpp
index 18a906e4c..4285eec6f 100644
--- a/tests/auto/core/qtransform/tst_qtransform.cpp
+++ b/tests/auto/core/qtransform/tst_qtransform.cpp
@@ -26,28 +26,18 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QtTest>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/qtransform.h>
 #include <Qt3DCore/qcomponent.h>
 #include <Qt3DCore/private/qtransform_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <QtCore/qscopedpointer.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 using namespace Qt3DCore;
 
 class FakeTransform : public Qt3DCore::QTransform
 {
 public:
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) override
-    {
-        Qt3DCore::QTransform::sceneChangeEvent(change);
-    }
 };
 
 class tst_QTransform : public QObject
@@ -73,63 +63,6 @@ private Q_SLOTS:
         QCOMPARE(transform.translation(), QVector3D(0.0f, 0.0f, 0.0f));
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DCore::QTransform *>("transform");
-
-        Qt3DCore::QTransform *defaultConstructed = new Qt3DCore::QTransform();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DCore::QTransform *matrixPropertySet = new Qt3DCore::QTransform();
-        matrixPropertySet->setMatrix(Qt3DCore::QTransform::rotateAround(QVector3D(0.1877f, 0.6868f, 0.3884f), 45.0f, QVector3D(0.0f, 0.0f, 1.0f)));
-        QTest::newRow("matrixPropertySet") << matrixPropertySet;
-
-        Qt3DCore::QTransform *translationSet = new Qt3DCore::QTransform();
-        translationSet->setTranslation(QVector3D(0.1877f, 0.6868f, 0.3884f));
-        QTest::newRow("translationSet") << translationSet;
-
-        Qt3DCore::QTransform *scaleSet = new Qt3DCore::QTransform();
-        scaleSet->setScale3D(QVector3D(0.1f, 0.6f, 0.3f));
-        QTest::newRow("scaleSet") << scaleSet;
-
-        Qt3DCore::QTransform *rotationSet = new Qt3DCore::QTransform();
-        scaleSet->setRotation(Qt3DCore::QTransform::fromAxisAndAngle(0.0f, 0.0f, 1.0f, 30.0f));
-        QTest::newRow("rotationSet") << rotationSet;
-
-        Qt3DCore::QTransform *eulerRotationSet = new Qt3DCore::QTransform();
-        eulerRotationSet->setRotationX(90.0f);
-        eulerRotationSet->setRotationY(10.0f);
-        eulerRotationSet->setRotationZ(1.0f);
-        QTest::newRow("eulerRotationSet") << eulerRotationSet;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DCore::QTransform *, transform);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(transform);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DCore::QTransformData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DCore::QTransformData>>(creationChanges.first());
-        const Qt3DCore::QTransformData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(creationChangeData->subjectId(), transform->id());
-        QCOMPARE(creationChangeData->isNodeEnabled(), transform->isEnabled());
-        QCOMPARE(creationChangeData->metaObject(), transform->metaObject());
-        QCOMPARE(creationChangeData->parentId(), transform->parentNode() ? transform->parentNode()->id() : Qt3DCore::QNodeId());
-        QCOMPARE(transform->translation(), cloneData.translation);
-        QCOMPARE(transform->scale3D(), cloneData.scale);
-        QCOMPARE(transform->rotation(), cloneData.rotation);
-        QCOMPARE(transform->worldMatrix(), QMatrix4x4());
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -141,30 +74,30 @@ private Q_SLOTS:
         transform->setTranslation(QVector3D(454.0f, 427.0f, 383.0f));
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), transform.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         QQuaternion q = Qt3DCore::QTransform::fromAxisAndAngle(QVector3D(0.0f, 1.0f, 0.0f), 90.0f);
         transform->setRotation(q);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), transform.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         transform->setScale3D(QVector3D(883.0f, 1200.0f, 1340.0f));
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), transform.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         // Force the transform to update its matrix
@@ -173,20 +106,20 @@ private Q_SLOTS:
         transform->setMatrix(QMatrix4x4());
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), transform.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         transform->setRotationX(20.0f);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), transform.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), transform.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkSignalEmittion()
@@ -353,27 +286,26 @@ private Q_SLOTS:
         QVERIFY(spy.isValid());
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        valueChange->setPropertyName("worldMatrix");
+        QTransformPrivate *dT = static_cast<QTransformPrivate *>(QNodePrivate::get(&t));
         const QMatrix4x4 newValue(1.0f, 2.0f, 3.0f, 4.0f,
                                   5.0f, 6.0f, 7.0f, 8.0f,
                                   9.0f, 10.0f, 11.0f, 12.0f,
                                   13.0f, 14.0f, 15.0f, 16.0f);
-        valueChange->setValue(newValue);
-        t.sceneChangeEvent(valueChange);
+        dT->setWorldMatrix(newValue);
+
 
         // THEN
         QCOMPARE(spy.count(), 1);
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
         QCOMPARE(t.worldMatrix(), newValue);
 
         // WHEN
         spy.clear();
-        t.sceneChangeEvent(valueChange);
+        dT->setWorldMatrix(newValue);
 
         // THEN
         QCOMPARE(spy.count(), 0);
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
         QCOMPARE(t.worldMatrix(), newValue);
     }
 };
diff --git a/tests/auto/coretest/coretest.pro b/tests/auto/coretest/coretest.pro
index 9a96dcc6f..57c7a0f0b 100644
--- a/tests/auto/coretest/coretest.pro
+++ b/tests/auto/coretest/coretest.pro
@@ -6,12 +6,6 @@ DEFINES += QT_NO_CAST_FROM_ASCII
 PRECOMPILED_HEADER =
 INCLUDEPATH += $$PWD
 
-SOURCES += \
-    $$PWD/testpostmanarbiter.cpp
-
-HEADERS += \
-    $$PWD/testpostmanarbiter_p.h
-
 qtConfig(private_tests) {
     SOURCES += \
         $$PWD/qbackendnodetester.cpp
diff --git a/tests/auto/coretest/qbackendnodetester.cpp b/tests/auto/coretest/qbackendnodetester.cpp
index bd5fb85d1..e0c2511fb 100644
--- a/tests/auto/coretest/qbackendnodetester.cpp
+++ b/tests/auto/coretest/qbackendnodetester.cpp
@@ -53,27 +53,6 @@ void QBackendNodeTester::setPeerId(QBackendNode *backend, QNodeId id)
     backend->setPeerId(id);
 }
 
-void QBackendNodeTester::simulateInitialization(QNode *frontend, QBackendNode *backend)
-{
-    Q_ASSERT(frontend);
-    Q_ASSERT(backend);
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_DEPRECATED
-    const auto change = frontend->createNodeCreationChange();
-    backend->setPeerId(change->subjectId());
-    backend->setEnabled(change->isNodeEnabled());
-    backend->initializeFromPeer(change);
-    QT_WARNING_POP
-}
-
-void QBackendNodeTester::sceneChangeEvent(QBackendNode *backend, const Qt3DCore::QSceneChangePtr &e)
-{
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_DEPRECATED
-    backend->sceneChangeEvent(e);
-    QT_WARNING_POP
-}
-
 } // namespace Qt3DCore
 
 QT_END_NAMESPACE
diff --git a/tests/auto/coretest/qbackendnodetester_p.h b/tests/auto/coretest/qbackendnodetester_p.h
index 020cfcdf1..910b87b4a 100644
--- a/tests/auto/coretest/qbackendnodetester_p.h
+++ b/tests/auto/coretest/qbackendnodetester_p.h
@@ -50,7 +50,6 @@
 
 #include <QObject>
 #include <Qt3DCore/qnodeid.h>
-#include <Qt3DCore/qscenechange.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -67,8 +66,6 @@ public:
 
     // Proxies to allow test classes to call private methods on QBackendNode
     void setPeerId(QBackendNode *backend, QNodeId id);
-    void simulateInitialization(QNode *frontend, QBackendNode *backend);
-    void sceneChangeEvent(QBackendNode *backend, const Qt3DCore::QSceneChangePtr &e);
 };
 
 } // namespace Qt3DCore
diff --git a/tests/auto/coretest/testpostmanarbiter.cpp b/tests/auto/coretest/testpostmanarbiter.cpp
deleted file mode 100644
index d2e404809..000000000
--- a/tests/auto/coretest/testpostmanarbiter.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
-#include "testpostmanarbiter_p.h"
-#include <Qt3DCore/private/qnode_p.h>
-
-#include <algorithm>
-#include <iterator>
-
-QT_BEGIN_NAMESPACE
-
-TestPostman::TestPostman(TestArbiter *arbiter)
-    : m_arbiter(arbiter)
-{}
-
-void TestPostman::setScene(Qt3DCore::QScene *)
-{}
-
-void TestPostman::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &)
-{}
-
-void TestPostman::notifyBackend(const Qt3DCore::QSceneChangePtr &e)
-{
-    m_arbiter->sceneChangeEventWithLock(e);
-}
-
-bool TestPostman::shouldNotifyFrontend(const Qt3DCore::QSceneChangePtr &)
-{
-    return false;
-}
-
-TestArbiter::TestArbiter()
-    : m_postman(new TestPostman(this))
-{
-}
-
-TestArbiter::~TestArbiter()
-{
-}
-
-void TestArbiter::sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
-{
-    events.push_back(e);
-}
-
-void TestArbiter::sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e)
-{
-    events.push_back(e);
-}
-
-void TestArbiter::sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &e)
-{
-    std::copy(e.cbegin(), e.cend(), std::back_inserter(events));
-}
-
-Qt3DCore::QAbstractPostman *TestArbiter::postman() const
-{
-    return m_postman;
-}
-
-void TestArbiter::setArbiterOnNode(Qt3DCore::QNode *node)
-{
-    Qt3DCore::QNodePrivate::get(node)->setArbiter(this);
-    for (Qt3DCore::QNode *n : node->childNodes())
-        setArbiterOnNode(n);
-}
-
-QT_END_NAMESPACE
diff --git a/tests/auto/coretest/testpostmanarbiter_p.h b/tests/auto/coretest/testpostmanarbiter_p.h
deleted file mode 100644
index 8954357fe..000000000
--- a/tests/auto/coretest/testpostmanarbiter_p.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-#ifndef QT3DCORE_TESTPOSTMANARBITER_P_H
-#define QT3DCORE_TESTPOSTMANARBITER_P_H
-
-//
-//  W A R N I N G
-//  -------------
-//
-// This file is not part of the Qt API.  It exists for the convenience
-// of other Qt classes.  This header file may change from version to
-// version without notice, or even be removed.
-//
-// We mean it.
-//
-
-#include <Qt3DCore/private/qpostman_p.h>
-#include <Qt3DCore/private/qchangearbiter_p.h>
-
-QT_BEGIN_NAMESPACE
-
-namespace Qt3DCore {
-    class QNode;
-} // Qt3D
-
-class TestArbiter;
-
-class TestPostman : public Qt3DCore::QAbstractPostman
-{
-public:
-    explicit TestPostman(TestArbiter *arbiter);
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) final;
-    void setScene(Qt3DCore::QScene *) final;
-    void notifyBackend(const Qt3DCore::QSceneChangePtr &e) final;
-    bool shouldNotifyFrontend(const Qt3DCore::QSceneChangePtr &e) final;
-
-private:
-    TestArbiter *m_arbiter;
-};
-
-class TestArbiter : public Qt3DCore::QAbstractArbiter
-{
-public:
-    TestArbiter();
-    ~TestArbiter();
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) final;
-
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e) final;
-
-    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &e) final;
-
-    Qt3DCore::QAbstractPostman *postman() const final;
-
-    QVector<Qt3DCore::QSceneChangePtr> events;
-
-    void setArbiterOnNode(Qt3DCore::QNode *node);
-
-private:
-    TestPostman *m_postman;
-};
-
-QT_END_NAMESPACE
-
-#endif // QT3DCORE_TESTPOSTMANARBITER_P_H
diff --git a/tests/auto/input/abstractaxisinput/tst_abstractaxisinput.cpp b/tests/auto/input/abstractaxisinput/tst_abstractaxisinput.cpp
index 94f02bc1e..691139075 100644
--- a/tests/auto/input/abstractaxisinput/tst_abstractaxisinput.cpp
+++ b/tests/auto/input/abstractaxisinput/tst_abstractaxisinput.cpp
@@ -43,15 +43,6 @@ public:
         : Qt3DInput::QAbstractAxisInput(*new Qt3DInput::QAbstractAxisInputPrivate, parent)
     {
     }
-
-private:
-    Qt3DCore::QNodeCreatedChangeBasePtr createNodeCreationChange() const override
-    {
-        auto creationChange = Qt3DCore::QNodeCreatedChangePtr<Qt3DInput::QAbstractAxisInputData>::create(this);
-        auto &data = creationChange->data;
-        data.sourceDeviceId = qIdForNode(sourceDevice());
-        return creationChange;
-    }
 };
 
 class DummyAxisInputBackend : public Qt3DInput::Input::AbstractAxisInput
diff --git a/tests/auto/input/action/tst_action.cpp b/tests/auto/input/action/tst_action.cpp
index cc40cef2f..b4a1b5331 100644
--- a/tests/auto/input/action/tst_action.cpp
+++ b/tests/auto/input/action/tst_action.cpp
@@ -30,13 +30,11 @@
 #include <qbackendnodetester.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
 #include <Qt3DInput/private/action_p.h>
 #include <Qt3DInput/QActionInput>
 #include <Qt3DInput/QAction>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class DummyActionInput : public Qt3DInput::QActionInput
 {
@@ -140,17 +138,14 @@ private Q_SLOTS:
     void shouldNotActivateWhenDisabled()
     {
         // GIVEN
-        TestArbiter arbiter;
         Qt3DInput::Input::Action backendAction;
         backendAction.setEnabled(false);
-        Qt3DCore::QBackendNodePrivate::get(&backendAction)->setArbiter(&arbiter);
 
         // WHEN
         backendAction.setActionTriggered(true);
 
         // THEN
         QVERIFY(!backendAction.actionTriggered());
-        QCOMPARE(arbiter.events.count(), 0);
     }
 };
 
diff --git a/tests/auto/input/axis/tst_axis.cpp b/tests/auto/input/axis/tst_axis.cpp
index ddd59b395..2f4cab10f 100644
--- a/tests/auto/input/axis/tst_axis.cpp
+++ b/tests/auto/input/axis/tst_axis.cpp
@@ -30,14 +30,12 @@
 #include <qbackendnodetester.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
 #include <Qt3DInput/private/axis_p.h>
 #include <Qt3DInput/private/qabstractaxisinput_p.h>
 #include <Qt3DInput/QAnalogAxisInput>
 #include <Qt3DInput/QAxis>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class DummyAxisInput : public Qt3DInput::QAbstractAxisInput
 {
@@ -141,9 +139,7 @@ private Q_SLOTS:
     void shouldNotChangeValueWhenDisabled()
     {
         // GIVEN
-        TestArbiter arbiter;
         Qt3DInput::Input::Axis backendAxis;
-        Qt3DCore::QBackendNodePrivate::get(&backendAxis)->setArbiter(&arbiter);
         backendAxis.setEnabled(false);
 
         // WHEN
@@ -151,7 +147,6 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(backendAxis.axisValue(), 0.0f);
-        QCOMPARE(arbiter.events.count(), 0);
     }
 };
 
diff --git a/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp b/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp
index f8d4adcd2..dda68c56b 100644
--- a/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp
+++ b/tests/auto/input/axisaccumulator/tst_axisaccumulator.cpp
@@ -38,7 +38,7 @@
 #include <Qt3DInput/QAxis>
 #include <Qt3DInput/QAxisAccumulator>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_AxisAccumulator: public Qt3DCore::QBackendNodeTester
 {
@@ -147,7 +147,6 @@ private Q_SLOTS:
         // GIVEN
         TestArbiter arbiter;
         Qt3DInput::Input::AxisAccumulator backendAxisAccumulator;
-        Qt3DCore::QBackendNodePrivate::get(&backendAxisAccumulator)->setArbiter(&arbiter);
         backendAxisAccumulator.setEnabled(false);
 
         // WHEN
@@ -155,7 +154,7 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(backendAxisAccumulator.value(), 0.0f);
-        QCOMPARE(arbiter.events.count(), 0);
+        QCOMPARE(arbiter.dirtyNodes().count(), 0);
     }
 
     void checkIntegration_data()
diff --git a/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp b/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp
index 91085357a..9a016b8fe 100644
--- a/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp
+++ b/tests/auto/input/axisaccumulatorjob/tst_axisaccumulatorjob.cpp
@@ -39,7 +39,7 @@
 #include <Qt3DInput/QAxis>
 #include <Qt3DInput/QAxisAccumulator>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_AxisAccumulatorJob : public Qt3DCore::QBackendNodeTester
 {
diff --git a/tests/auto/input/commons/testdevice.h b/tests/auto/input/commons/testdevice.h
index 936a0d1b2..61f39e4bf 100644
--- a/tests/auto/input/commons/testdevice.h
+++ b/tests/auto/input/commons/testdevice.h
@@ -60,7 +60,7 @@ public:
     explicit TestDeviceBackendNode(TestDevice *device)
         : Qt3DInput::QAbstractPhysicalDeviceBackendNode(ReadOnly)
     {
-        Qt3DCore::QBackendNodeTester().simulateInitialization(device, this);
+        Qt3DCore::QBackendNodeTester().simulateInitializationSync(device, this);
     }
 
     float axisValue(int axisIdentifier) const final
diff --git a/tests/auto/input/loadproxydevicejob/tst_loadproxydevicejob.cpp b/tests/auto/input/loadproxydevicejob/tst_loadproxydevicejob.cpp
index c5322eda6..de4875e0e 100644
--- a/tests/auto/input/loadproxydevicejob/tst_loadproxydevicejob.cpp
+++ b/tests/auto/input/loadproxydevicejob/tst_loadproxydevicejob.cpp
@@ -36,7 +36,7 @@
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include "qbackendnodetester.h"
 #include "testdeviceproxy.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class FakeInputDeviceIntegration : public Qt3DInput::QInputDeviceIntegration
 {
@@ -118,7 +118,6 @@ private Q_SLOTS:
                 backendProxy->setManager(manager);
                 Qt3DCore::QBackendNodeTester backendNodeCreator;
                 backendNodeCreator.simulateInitializationSync(&proxy, backendProxy);
-                Qt3DCore::QBackendNodePrivate::get(backendProxy)->setArbiter(&arbiter);
             }
 
             // THEN
@@ -152,7 +151,6 @@ private Q_SLOTS:
                 backendProxy->setManager(manager);
                 Qt3DCore::QBackendNodeTester backendNodeCreator;
                 backendNodeCreator.simulateInitializationSync(&proxy, backendProxy);
-                Qt3DCore::QBackendNodePrivate::get(backendProxy)->setArbiter(&arbiter);
             }
 
             // THEN
@@ -171,7 +169,7 @@ private Q_SLOTS:
             job.run();
 
             // THEN -> PhysicalDeviceWrapper::setDevice should not have been called
-            QCOMPARE(arbiter.events.count(), 0);
+            QCOMPARE(arbiter.dirtyNodes().count(), 0);
         }
     }
 
diff --git a/tests/auto/input/physicaldeviceproxy/tst_physicaldeviceproxy.cpp b/tests/auto/input/physicaldeviceproxy/tst_physicaldeviceproxy.cpp
index bd5da8e3f..a6059f1f0 100644
--- a/tests/auto/input/physicaldeviceproxy/tst_physicaldeviceproxy.cpp
+++ b/tests/auto/input/physicaldeviceproxy/tst_physicaldeviceproxy.cpp
@@ -35,7 +35,7 @@
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include "qbackendnodetester.h"
 #include "testdeviceproxy.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 
 class tst_PhysicalDeviceProxy : public Qt3DCore::QBackendNodeTester
diff --git a/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp b/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp
index 4e9f609c4..5b59a8de0 100644
--- a/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp
+++ b/tests/auto/input/qabstractaxisinput/tst_qabstractaxisinput.cpp
@@ -34,8 +34,8 @@
 #include <Qt3DInput/QAbstractPhysicalDevice>
 #include <Qt3DInput/private/qabstractaxisinput_p.h>
 
-#include "testpostmanarbiter.h"
 #include "testdevice.h"
+#include <testarbiter.h>
 
 class DummyAxisInput : public Qt3DInput::QAbstractAxisInput
 {
@@ -68,15 +68,15 @@ private Q_SLOTS:
         // WHEN
         TestDevice *device = new TestDevice(axisInput.data());
         QCoreApplication::processEvents();
-        arbiter.events.clear();
+        arbiter.clear();
 
         axisInput->setSourceDevice(device);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkSourceDeviceBookkeeping()
diff --git a/tests/auto/input/qabstractphysicaldevicebackendnode/tst_qabstractphysicaldevicebackendnode.cpp b/tests/auto/input/qabstractphysicaldevicebackendnode/tst_qabstractphysicaldevicebackendnode.cpp
index 247a881ad..0add25778 100644
--- a/tests/auto/input/qabstractphysicaldevicebackendnode/tst_qabstractphysicaldevicebackendnode.cpp
+++ b/tests/auto/input/qabstractphysicaldevicebackendnode/tst_qabstractphysicaldevicebackendnode.cpp
@@ -36,7 +36,6 @@
 #include <Qt3DInput/private/qinputaspect_p.h>
 #include <Qt3DInput/private/inputmanagers_p.h>
 #include <Qt3DInput/private/axissetting_p.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
 #include "testdevice.h"
 
 class TestPhysicalDeviceBackendNode : public Qt3DInput::QAbstractPhysicalDeviceBackendNode
diff --git a/tests/auto/input/qabstractphysicaldeviceproxy/tst_qabstractphysicaldeviceproxy.cpp b/tests/auto/input/qabstractphysicaldeviceproxy/tst_qabstractphysicaldeviceproxy.cpp
index bbe184e0e..f17fba297 100644
--- a/tests/auto/input/qabstractphysicaldeviceproxy/tst_qabstractphysicaldeviceproxy.cpp
+++ b/tests/auto/input/qabstractphysicaldeviceproxy/tst_qabstractphysicaldeviceproxy.cpp
@@ -29,8 +29,6 @@
 
 #include <QtTest/QTest>
 
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
 #include "testdeviceproxy.h"
 
 class tst_QAbstractPhysicalDeviceProxy : public QObject
@@ -72,58 +70,6 @@ private Q_SLOTS:
         // THEN -> should not crash
         QVERIFY(abstractPhysicalDeviceProxy->device() == nullptr);
     }
-
-    void checkCreationData()
-    {
-        // GIVEN
-        TestProxy abstractPhysicalDeviceProxy;
-
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractPhysicalDeviceProxy);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QAbstractPhysicalDeviceProxyData>>(creationChanges.first());
-            const Qt3DInput::QAbstractPhysicalDeviceProxyData cloneData = creationChangeData->data;
-
-            QCOMPARE(abstractPhysicalDeviceProxy.deviceName(), cloneData.deviceName);
-            QCOMPARE(abstractPhysicalDeviceProxy.id(), creationChangeData->subjectId());
-            QCOMPARE(abstractPhysicalDeviceProxy.isEnabled(), true);
-            QCOMPARE(abstractPhysicalDeviceProxy.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(abstractPhysicalDeviceProxy.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        abstractPhysicalDeviceProxy.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractPhysicalDeviceProxy);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QAbstractPhysicalDeviceProxyData>>(creationChanges.first());
-            const Qt3DInput::QAbstractPhysicalDeviceProxyData cloneData = creationChangeData->data;
-
-            QCOMPARE(abstractPhysicalDeviceProxy.deviceName(), cloneData.deviceName);
-            QCOMPARE(abstractPhysicalDeviceProxy.id(), creationChangeData->subjectId());
-            QCOMPARE(abstractPhysicalDeviceProxy.isEnabled(), false);
-            QCOMPARE(abstractPhysicalDeviceProxy.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(abstractPhysicalDeviceProxy.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
 };
 
 QTEST_MAIN(tst_QAbstractPhysicalDeviceProxy)
diff --git a/tests/auto/input/qaction/tst_qaction.cpp b/tests/auto/input/qaction/tst_qaction.cpp
index 13c4a2d83..dc8f5cbc7 100644
--- a/tests/auto/input/qaction/tst_qaction.cpp
+++ b/tests/auto/input/qaction/tst_qaction.cpp
@@ -29,14 +29,12 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/QAction>
 #include <Qt3DInput/QActionInput>
 #include <Qt3DInput/private/qaction_p.h>
 #include <Qt3DInput/private/qactioninput_p.h>
-
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 // We need to call QNode::clone which is protected
 // We need to call QAction::sceneChangeEvent which is protected
@@ -51,53 +49,7 @@ public:
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DInput::QAction *>("action");
-
-        Qt3DInput::QAction *defaultConstructed = new Qt3DInput::QAction();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DInput::QAction *namedaction = new Qt3DInput::QAction();
-        QTest::newRow("namedAction") << namedaction;
-
-        Qt3DInput::QAction *namedactionWithInputs = new Qt3DInput::QAction();
-        Qt3DInput::QActionInput *actionInput1 = new Qt3DInput::QActionInput();
-        Qt3DInput::QActionInput *actionInput2 = new Qt3DInput::QActionInput();
-        Qt3DInput::QActionInput *actionInput3 = new Qt3DInput::QActionInput();
-        namedactionWithInputs->addInput(actionInput1);
-        namedactionWithInputs->addInput(actionInput2);
-        namedactionWithInputs->addInput(actionInput3);
-        QTest::newRow("namedActionWithInputs") << namedactionWithInputs;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DInput::QAction *, action);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(action);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + action->inputs().size());
 
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DInput::QActionData> creationChangeData =
-               qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QActionData>>(creationChanges.first());
-        const Qt3DInput::QActionData &cloneActionData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(creationChangeData->subjectId(), action->id());
-        QCOMPARE(creationChangeData->isNodeEnabled(), action->isEnabled());
-        QCOMPARE(creationChangeData->metaObject(), action->metaObject());
-        QCOMPARE(creationChangeData->parentId(), action->parentNode() ? action->parentNode()->id() : Qt3DCore::QNodeId());
-        QCOMPARE(cloneActionData.inputIds.size(), action->inputs().size());
-
-        const QVector<Qt3DInput::QAbstractActionInput *> &inputs = action->inputs();
-        for (int i = 0, m = inputs.size(); i < m; ++i)
-            QCOMPARE(cloneActionData.inputIds.at(i), inputs.at(i)->id());
-    }
 
     void checkPropertyUpdates()
     {
@@ -112,22 +64,18 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), action.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), action.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         action->removeInput(input);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), action.data());
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), action.data());
     }
 
     void checkActionInputBookkeeping()
diff --git a/tests/auto/input/qactioninput/tst_qactioninput.cpp b/tests/auto/input/qactioninput/tst_qactioninput.cpp
index be06cd8b2..985efb534 100644
--- a/tests/auto/input/qactioninput/tst_qactioninput.cpp
+++ b/tests/auto/input/qactioninput/tst_qactioninput.cpp
@@ -30,14 +30,13 @@
 #include <Qt3DCore/qnodeid.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/private/qactioninput_p.h>
 #include <Qt3DInput/QActionInput>
 #include <Qt3DInput/QAbstractPhysicalDevice>
 
-#include "testpostmanarbiter.h"
 #include "testdevice.h"
+#include <testarbiter.h>
 
 class tst_QActionInput: public QObject
 {
@@ -49,47 +48,6 @@ public:
     }
 
 private Q_SLOTS:
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DInput::QActionInput *>("actionInput");
-
-        Qt3DInput::QActionInput *defaultConstructed = new Qt3DInput::QActionInput();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DInput::QActionInput *actionInputWithKeys = new Qt3DInput::QActionInput();
-        actionInputWithKeys->setButtons(QVector<int>() << ((1 << 1) | (1 << 5)));
-        QTest::newRow("actionInputWithKeys") << actionInputWithKeys;
-
-        Qt3DInput::QActionInput *actionInputWithKeysAndSourceDevice = new Qt3DInput::QActionInput();
-        TestDevice *device = new TestDevice();
-        actionInputWithKeysAndSourceDevice->setButtons(QVector<int>() << ((1 << 1) | (1 << 5)));
-        actionInputWithKeysAndSourceDevice->setSourceDevice(device);
-        QTest::newRow("actionInputWithKeysAndSourceDevice") << actionInputWithKeysAndSourceDevice;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DInput::QActionInput *, actionInput);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(actionInput);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (actionInput->sourceDevice() ? 1 : 0));
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DInput::QActionInputData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QActionInputData>>(creationChanges.first());
-        const Qt3DInput::QActionInputData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(actionInput->id(), creationChangeData->subjectId());
-        QCOMPARE(actionInput->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(actionInput->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(actionInput->buttons(), cloneData.buttons);
-        QCOMPARE(actionInput->sourceDevice() ? actionInput->sourceDevice()->id() : Qt3DCore::QNodeId(), cloneData.sourceDeviceId);
-    }
 
     void checkPropertyUpdates()
     {
@@ -103,23 +61,22 @@ private Q_SLOTS:
         actionInput->setButtons(buttons);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), actionInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), actionInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         TestDevice *device = new TestDevice(actionInput.data());
         QCoreApplication::processEvents();
-        arbiter.events.clear();
 
         actionInput->setSourceDevice(device);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), actionInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), actionInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkSourceDeviceBookkeeping()
diff --git a/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp b/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp
index c9abd0f4b..07149afef 100644
--- a/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp
+++ b/tests/auto/input/qanalogaxisinput/tst_qanalogaxisinput.cpp
@@ -29,14 +29,13 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/QAnalogAxisInput>
 #include <Qt3DInput/QAbstractPhysicalDevice>
 #include <Qt3DInput/private/qanalogaxisinput_p.h>
 
-#include "testpostmanarbiter.h"
 #include "testdevice.h"
+#include <testarbiter.h>
 
 class tst_QAnalogAxisInput: public QObject
 {
@@ -48,45 +47,6 @@ public:
     }
 
 private Q_SLOTS:
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DInput::QAnalogAxisInput *>("axisInput");
-
-        Qt3DInput::QAnalogAxisInput *defaultConstructed = new Qt3DInput::QAnalogAxisInput();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DInput::QAnalogAxisInput *axisInputWithAxis = new Qt3DInput::QAnalogAxisInput();
-        axisInputWithAxis->setAxis(383);
-        QTest::newRow("axisInputWithAxis") << axisInputWithAxis;
-
-        Qt3DInput::QAnalogAxisInput *axisInputWithAxisAndSourceDevice = new Qt3DInput::QAnalogAxisInput();
-        TestDevice *device = new TestDevice();
-        axisInputWithAxisAndSourceDevice->setSourceDevice(device);
-        axisInputWithAxisAndSourceDevice->setAxis(427);
-        QTest::newRow("axisInputWithAxisAndSourceDevice") << axisInputWithAxisAndSourceDevice;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DInput::QAnalogAxisInput *, axisInput);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(axisInput);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (axisInput->sourceDevice() ? 1 : 0));
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DInput::QAnalogAxisInputData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QAnalogAxisInputData>>(creationChanges.first());
-        const Qt3DInput::QAnalogAxisInputData &cloneData = creationChangeData->data;
-        QCOMPARE(axisInput->id(), creationChangeData->subjectId());
-        QCOMPARE(axisInput->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(axisInput->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(axisInput->axis(), cloneData.axis);
-        QCOMPARE(axisInput->sourceDevice() ? axisInput->sourceDevice()->id() : Qt3DCore::QNodeId(), cloneData.sourceDeviceId);
-    }
 
     void checkPropertyUpdates()
     {
@@ -99,23 +59,22 @@ private Q_SLOTS:
         axisInput->setAxis(350);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         TestDevice *device = new TestDevice(axisInput.data());
         QCoreApplication::processEvents();
-        arbiter.events.clear();
 
         axisInput->setSourceDevice(device);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 };
 
diff --git a/tests/auto/input/qaxis/tst_qaxis.cpp b/tests/auto/input/qaxis/tst_qaxis.cpp
index 9b3068442..e57b02bb3 100644
--- a/tests/auto/input/qaxis/tst_qaxis.cpp
+++ b/tests/auto/input/qaxis/tst_qaxis.cpp
@@ -29,13 +29,11 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/QAxis>
 #include <Qt3DInput/QAnalogAxisInput>
 #include <Qt3DInput/private/qaxis_p.h>
-
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_QAxis: public QObject
 {
@@ -47,52 +45,6 @@ public:
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DInput::QAxis *>("axis");
-
-        Qt3DInput::QAxis *defaultConstructed = new Qt3DInput::QAxis();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DInput::QAxis *namedAxis = new Qt3DInput::QAxis();
-        QTest::newRow("namedAxis") << namedAxis;
-
-        Qt3DInput::QAxis *namedAxisWithInputs = new Qt3DInput::QAxis();
-        Qt3DInput::QAbstractAxisInput *axisInput1 = new Qt3DInput::QAnalogAxisInput();
-        Qt3DInput::QAbstractAxisInput *axisInput2 = new Qt3DInput::QAnalogAxisInput();
-        Qt3DInput::QAbstractAxisInput *axisInput3 = new Qt3DInput::QAnalogAxisInput();
-        namedAxisWithInputs->addInput(axisInput1);
-        namedAxisWithInputs->addInput(axisInput2);
-        namedAxisWithInputs->addInput(axisInput3);
-        QTest::newRow("namedAxisWithInputs") << namedAxisWithInputs;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DInput::QAxis *, axis);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(axis);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + axis->inputs().size());
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DInput::QAxisData> creationChangeData =
-               qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QAxisData>>(creationChanges.first());
-        const Qt3DInput::QAxisData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(axis->id(), creationChangeData->subjectId());
-        QCOMPARE(axis->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(axis->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(axis->inputs().count(), cloneData.inputIds.count());
-
-        for (int i = 0, m = axis->inputs().count(); i < m; ++i)
-            QCOMPARE(axis->inputs().at(i)->id(), cloneData.inputIds.at(i));
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -106,22 +58,20 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axis.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axis.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         axis->removeInput(input);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axis.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axis.data());
 
-        arbiter.events.clear();
+        arbiter.clear();
     }
 
     void checkAxisInputBookkeeping()
diff --git a/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp b/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp
index 9f96cd845..fea5d925a 100644
--- a/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp
+++ b/tests/auto/input/qaxisaccumulator/tst_qaxisaccumulator.cpp
@@ -29,13 +29,12 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/qaxis.h>
 #include <Qt3DInput/qaxisaccumulator.h>
 #include <Qt3DInput/private/qaxisaccumulator_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QAxisAccumulator: public Qt3DInput::QAxisAccumulator
 {
@@ -47,76 +46,6 @@ public:
 
 private Q_SLOTS:
 
-    void checkCreationChange_data()
-    {
-        QTest::addColumn<QSharedPointer<Qt3DInput::QAxisAccumulator>>("accumulator");
-        QTest::addColumn<Qt3DInput::QAxis *>("sourceAxis");
-        QTest::addColumn<Qt3DInput::QAxisAccumulator::SourceAxisType>("sourceAxisType");
-        QTest::addColumn<float>("scale");
-
-        {
-            auto accumulator = QSharedPointer<Qt3DInput::QAxisAccumulator>::create();
-            QTest::newRow("defaultConstructed")
-                    << accumulator
-                    << static_cast<Qt3DInput::QAxis *>(nullptr)
-                    << Qt3DInput::QAxisAccumulator::Velocity
-                    << 1.0f;
-        }
-
-        {
-            auto accumulator = QSharedPointer<Qt3DInput::QAxisAccumulator>::create();
-            Qt3DInput::QAxis *axis = new Qt3DInput::QAxis();
-            accumulator->setSourceAxis(axis);
-            QTest::newRow("withSourceAxis")
-                    << accumulator
-                    << axis
-                    << Qt3DInput::QAxisAccumulator::Velocity
-                    << 1.0f;
-        }
-
-        {
-            auto accumulator = QSharedPointer<Qt3DInput::QAxisAccumulator>::create();
-            accumulator->setSourceAxisType(Qt3DInput::QAxisAccumulator::Acceleration);
-            accumulator->setScale(2.5f);
-            Qt3DInput::QAxis *axis = new Qt3DInput::QAxis();
-            accumulator->setSourceAxis(axis);
-            QTest::newRow("accelerationNonUniformScale")
-                    << accumulator
-                    << axis
-                    << Qt3DInput::QAxisAccumulator::Acceleration
-                    << 2.5f;
-        }
-    }
-
-    void checkCreationChange()
-    {
-        // GIVEN
-        QFETCH(QSharedPointer<Qt3DInput::QAxisAccumulator>, accumulator);
-        QFETCH(Qt3DInput::QAxis *, sourceAxis);
-        QFETCH(Qt3DInput::QAxisAccumulator::SourceAxisType, sourceAxisType);
-        QFETCH(float, scale);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(accumulator.data());
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), sourceAxis ? 2 : 1);
-
-        const auto creationChangeData =
-               qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QAxisAccumulatorData>>(creationChanges.first());
-        const Qt3DInput::QAxisAccumulatorData &creationData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(accumulator->id(), creationChangeData->subjectId());
-        QCOMPARE(accumulator->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(accumulator->metaObject(), creationChangeData->metaObject());
-        if (sourceAxis)
-            QCOMPARE(sourceAxis->id(), creationData.sourceAxisId);
-        QCOMPARE(sourceAxisType, creationData.sourceAxisType);
-        QCOMPARE(scale, creationData.scale);
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -129,29 +58,29 @@ private Q_SLOTS:
         accumulator->setSourceAxis(axis);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), accumulator.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), accumulator.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
 
         // WHEN
         accumulator->setScale(2.0f);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), accumulator.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), accumulator.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         accumulator->setSourceAxisType(Qt3DInput::QAxisAccumulator::Acceleration);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), accumulator.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), accumulator.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkAxisInputBookkeeping()
diff --git a/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp b/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp
index e8ab3e172..6a53c1b89 100644
--- a/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp
+++ b/tests/auto/input/qbuttonaxisinput/tst_qbuttonaxisinput.cpp
@@ -29,13 +29,12 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/QAbstractPhysicalDevice>
 #include <Qt3DInput/QButtonAxisInput>
 #include <Qt3DInput/private/qbuttonaxisinput_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 #include "testdevice.h"
 
 class tst_QButtonAxisInput: public QObject
@@ -60,56 +59,6 @@ private Q_SLOTS:
         QCOMPARE(axisInput.deceleration(), -1.0f);
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DInput::QButtonAxisInput *>("axisInput");
-
-        Qt3DInput::QButtonAxisInput *defaultConstructed = new Qt3DInput::QButtonAxisInput();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DInput::QButtonAxisInput *axisInputWithKeys = new Qt3DInput::QButtonAxisInput();
-        axisInputWithKeys->setButtons(QVector<int>() << ((1 << 1) | (1 << 5)));
-        axisInputWithKeys->setScale(327.0f);
-        QTest::newRow("axisInputWithKeys") << axisInputWithKeys;
-
-        Qt3DInput::QButtonAxisInput *axisInputWithKeysAndSourceDevice = new Qt3DInput::QButtonAxisInput();
-        TestDevice *device = new TestDevice();
-        axisInputWithKeysAndSourceDevice->setButtons(QVector<int>() << ((1 << 1) | (1 << 5)));
-        axisInputWithKeysAndSourceDevice->setSourceDevice(device);
-        axisInputWithKeysAndSourceDevice->setScale(355.0f);
-        QTest::newRow("axisInputWithKeysAndSourceDevice") << axisInputWithKeysAndSourceDevice;
-
-        Qt3DInput::QButtonAxisInput *axisInputWithAcceleration = new Qt3DInput::QButtonAxisInput();
-        axisInputWithAcceleration->setAcceleration(41.0f);
-        axisInputWithAcceleration->setDeceleration(42.0f);
-        QTest::newRow("axisInputWithAcceleration") << axisInputWithAcceleration;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DInput::QButtonAxisInput *, axisInput);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(axisInput);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (axisInput->sourceDevice() ? 1 : 0));
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DInput::QButtonAxisInputData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QButtonAxisInputData>>(creationChanges.first());
-        const Qt3DInput::QButtonAxisInputData &cloneData = creationChangeData->data;
-        QCOMPARE(axisInput->id(), creationChangeData->subjectId());
-        QCOMPARE(axisInput->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(axisInput->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(axisInput->buttons(), cloneData.buttons);
-        QCOMPARE(axisInput->scale(), cloneData.scale);
-        QCOMPARE(axisInput->acceleration(), cloneData.acceleration);
-        QCOMPARE(axisInput->deceleration(), cloneData.deceleration);
-        QCOMPARE(axisInput->sourceDevice() ? axisInput->sourceDevice()->id() : Qt3DCore::QNodeId(), cloneData.sourceDeviceId);
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -122,19 +71,19 @@ private Q_SLOTS:
         axisInput->setButtons(buttons);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         axisInput->setScale(1340.0f);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         TestDevice *device = new TestDevice(axisInput.data());
@@ -142,28 +91,28 @@ private Q_SLOTS:
         axisInput->setSourceDevice(device);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         axisInput->setAcceleration(42.0f);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         axisInput->setDeceleration(43.0f);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), axisInput.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), axisInput.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 };
 
diff --git a/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp b/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp
index 3f1e7fd09..7f1b7af62 100644
--- a/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp
+++ b/tests/auto/input/qkeyboardhandler/tst_qkeyboardhandler.cpp
@@ -29,13 +29,11 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/QKeyboardDevice>
 #include <Qt3DInput/QKeyboardHandler>
 #include <Qt3DInput/private/qkeyboardhandler_p.h>
-
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_QKeyboardHandler : public QObject
 {
@@ -47,44 +45,6 @@ public:
     }
 
 private Q_SLOTS:
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DInput::QKeyboardHandler *>("keyboardHandler");
-
-        auto defaultConstructed = new Qt3DInput::QKeyboardHandler;
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        auto handlerWithDevice = new Qt3DInput::QKeyboardHandler;
-        handlerWithDevice->setSourceDevice(new Qt3DInput::QKeyboardDevice);
-        QTest::newRow("handlerWithDevice") << handlerWithDevice;
-
-        auto handlerWithDeviceAndFocus = new Qt3DInput::QKeyboardHandler;
-        handlerWithDeviceAndFocus->setSourceDevice(new Qt3DInput::QKeyboardDevice);
-        handlerWithDeviceAndFocus->setFocus(true);
-        QTest::newRow("handlerWithDeviceAndFocus") << handlerWithDeviceAndFocus;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DInput::QKeyboardHandler *, keyboardHandler);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(keyboardHandler);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (keyboardHandler->sourceDevice() ? 1 : 0));
-
-        auto creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QKeyboardHandlerData>>(creationChanges.first());
-        const Qt3DInput::QKeyboardHandlerData &cloneData = creationChangeData->data;
-        QCOMPARE(keyboardHandler->id(), creationChangeData->subjectId());
-        QCOMPARE(keyboardHandler->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(keyboardHandler->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(keyboardHandler->focus(), cloneData.focus);
-        QCOMPARE(keyboardHandler->sourceDevice() ? keyboardHandler->sourceDevice()->id() : Qt3DCore::QNodeId(), cloneData.keyboardDeviceId);
-    }
 
     void checkPropertyUpdates()
     {
@@ -97,23 +57,23 @@ private Q_SLOTS:
         keyboardHandler->setFocus(true);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), keyboardHandler.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), keyboardHandler.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         auto device = new Qt3DInput::QKeyboardDevice(keyboardHandler.data());
         QCoreApplication::processEvents();
-        arbiter.events.clear();
+        arbiter.clear();
 
         keyboardHandler->setSourceDevice(device);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), keyboardHandler.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), keyboardHandler.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkSourceDeviceBookkeeping()
diff --git a/tests/auto/input/qlogicaldevice/tst_qlogicaldevice.cpp b/tests/auto/input/qlogicaldevice/tst_qlogicaldevice.cpp
index c7236ac7d..6e3616368 100644
--- a/tests/auto/input/qlogicaldevice/tst_qlogicaldevice.cpp
+++ b/tests/auto/input/qlogicaldevice/tst_qlogicaldevice.cpp
@@ -29,14 +29,13 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DInput/QLogicalDevice>
 #include <Qt3DInput/private/qlogicaldevice_p.h>
 #include <Qt3DInput/QAxis>
 #include <Qt3DInput/QAction>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QLogicalDevice: public QObject
 {
@@ -49,59 +48,6 @@ public:
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DInput::QLogicalDevice *>("logicalDevice");
-
-        Qt3DInput::QLogicalDevice *defaultConstructed = new Qt3DInput::QLogicalDevice();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DInput::QLogicalDevice *logicalDeviceWithActions = new Qt3DInput::QLogicalDevice();
-        logicalDeviceWithActions->addAction(new Qt3DInput::QAction());
-        logicalDeviceWithActions->addAction(new Qt3DInput::QAction());
-        logicalDeviceWithActions->addAction(new Qt3DInput::QAction());
-        QTest::newRow("logicalDeviceWithActions") << logicalDeviceWithActions;
-
-        Qt3DInput::QLogicalDevice *logicalDeviceWithAxes = new Qt3DInput::QLogicalDevice();
-        logicalDeviceWithAxes->addAxis(new Qt3DInput::QAxis());
-        logicalDeviceWithAxes->addAxis(new Qt3DInput::QAxis());
-        logicalDeviceWithAxes->addAxis(new Qt3DInput::QAxis());
-        QTest::newRow("logicalDeviceWithAxes") << logicalDeviceWithAxes;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DInput::QLogicalDevice *, logicalDevice);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(logicalDevice);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        const int axesCount = logicalDevice->axes().count();
-        const int actionsCount = logicalDevice->actions().count();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + axesCount + actionsCount);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DInput::QLogicalDeviceData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QLogicalDeviceData>>(creationChanges.first());
-        const Qt3DInput::QLogicalDeviceData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(logicalDevice->id(), creationChangeData->subjectId());
-        QCOMPARE(logicalDevice->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(logicalDevice->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(axesCount, cloneData.axisIds.count());
-        QCOMPARE(actionsCount, cloneData.actionIds.count());
-
-        for (int i = 0; i < axesCount; ++i)
-            QCOMPARE(logicalDevice->axes().at(i)->id(), cloneData.axisIds.at(i));
-
-        for (int i = 0; i < actionsCount; ++i)
-            QCOMPARE(logicalDevice->actions().at(i)->id(), cloneData.actionIds.at(i));
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -112,54 +58,50 @@ private Q_SLOTS:
         // WHEN
         Qt3DInput::QAction *action = new Qt3DInput::QAction(logicalDevice.data());
         QCoreApplication::processEvents();
-        arbiter.events.clear();
+        arbiter.clear();
 
         logicalDevice->addAction(action);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), logicalDevice.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), logicalDevice.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         logicalDevice->removeAction(action);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), logicalDevice.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), logicalDevice.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DInput::QAxis *axis = new Qt3DInput::QAxis(logicalDevice.data());
         QCoreApplication::processEvents();
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         logicalDevice->addAxis(axis);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), logicalDevice.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), logicalDevice.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         logicalDevice->removeAxis(axis);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), logicalDevice.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), logicalDevice.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkAxisBookkeeping()
diff --git a/tests/auto/input/qmousedevice/tst_qmousedevice.cpp b/tests/auto/input/qmousedevice/tst_qmousedevice.cpp
index 6a8f39c71..cd899d661 100644
--- a/tests/auto/input/qmousedevice/tst_qmousedevice.cpp
+++ b/tests/auto/input/qmousedevice/tst_qmousedevice.cpp
@@ -33,9 +33,7 @@
 #include <Qt3DInput/private/qmousedevice_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QMouseDevice : public QObject
 {
@@ -118,58 +116,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DInput::QMouseDevice mouseDevice;
-
-        mouseDevice.setSensitivity(0.8f);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mouseDevice);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QMouseDeviceData>>(creationChanges.first());
-            const Qt3DInput::QMouseDeviceData cloneData = creationChangeData->data;
-
-            QCOMPARE(mouseDevice.sensitivity(), cloneData.sensitivity);
-            QCOMPARE(mouseDevice.id(), creationChangeData->subjectId());
-            QCOMPARE(mouseDevice.isEnabled(), true);
-            QCOMPARE(mouseDevice.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mouseDevice.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        mouseDevice.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mouseDevice);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DInput::QMouseDeviceData>>(creationChanges.first());
-            const Qt3DInput::QMouseDeviceData cloneData = creationChangeData->data;
-
-            QCOMPARE(mouseDevice.sensitivity(), cloneData.sensitivity);
-            QCOMPARE(mouseDevice.id(), creationChangeData->subjectId());
-            QCOMPARE(mouseDevice.isEnabled(), false);
-            QCOMPARE(mouseDevice.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mouseDevice.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkSensitivityUpdate()
     {
         // GIVEN
@@ -181,16 +127,16 @@ private Q_SLOTS:
             // WHEN
             mouseDevice.setSensitivity(0.7f);
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mouseDevice);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mouseDevice);
         }
 
         {
             // WHEN
             mouseDevice.setSensitivity(0.7f);
 
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mouseDevice);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mouseDevice);
         }
 
     }
@@ -206,16 +152,16 @@ private Q_SLOTS:
             // WHEN
             mouseDevice.setUpdateAxesContinuously(true);
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mouseDevice);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mouseDevice);
         }
 
         {
             // WHEN
             mouseDevice.setSensitivity(true);
 
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mouseDevice);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mouseDevice);
         }
 
     }
diff --git a/tests/auto/input/utils/tst_utils.cpp b/tests/auto/input/utils/tst_utils.cpp
index 14a289556..daa03efd9 100644
--- a/tests/auto/input/utils/tst_utils.cpp
+++ b/tests/auto/input/utils/tst_utils.cpp
@@ -133,7 +133,7 @@ private Q_SLOTS:
         // WHEN -> Create backend PhysicalProxiDevice
         Qt3DInput::Input::PhysicalDeviceProxy *backendProxyDevice = handler.physicalDeviceProxyManager()->getOrCreateResource(testProxyPhysicalDevice.id());
         backendProxyDevice->setManager(handler.physicalDeviceProxyManager());
-        simulateInitialization(&testProxyPhysicalDevice, backendProxyDevice);
+        simulateInitializationSync(&testProxyPhysicalDevice, backendProxyDevice);
         backendProxyDevice->setDevice(&testPhysicalDevice);
 
         // THEN
@@ -204,7 +204,7 @@ private Q_SLOTS:
         // WHEN -> Create backend PhysicalProxiDevice
         Qt3DInput::Input::PhysicalDeviceProxy *backendProxyDevice = handler.physicalDeviceProxyManager()->getOrCreateResource(testProxyPhysicalDevice.id());
         backendProxyDevice->setManager(handler.physicalDeviceProxyManager());
-        simulateInitialization(&testProxyPhysicalDevice, backendProxyDevice);
+        simulateInitializationSync(&testProxyPhysicalDevice, backendProxyDevice);
         backendProxyDevice->setDevice(&testPhysicalDevice2);
 
         // THEN
diff --git a/tests/auto/render/armature/tst_armature.cpp b/tests/auto/render/armature/tst_armature.cpp
index 99b9aa7a5..055013850 100644
--- a/tests/auto/render/armature/tst_armature.cpp
+++ b/tests/auto/render/armature/tst_armature.cpp
@@ -34,7 +34,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 
 using namespace Qt3DCore;
 using namespace Qt3DRender;
diff --git a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
index 34d195221..cec48c066 100644
--- a/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
+++ b/tests/auto/render/boundingsphere/tst_boundingsphere.cpp
@@ -27,7 +27,7 @@
 ****************************************************************************/
 
 #include "qmlscenereader.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 #include <QUrl>
 
diff --git a/tests/auto/render/buffer/tst_buffer.cpp b/tests/auto/render/buffer/tst_buffer.cpp
index 5c2ae296d..c021ea805 100644
--- a/tests/auto/render/buffer/tst_buffer.cpp
+++ b/tests/auto/render/buffer/tst_buffer.cpp
@@ -35,9 +35,8 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DRender/private/buffer_p.h>
 #include <Qt3DRender/private/qbuffer_p.h>
 #include <Qt3DRender/private/buffermanager_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 #include "testrenderer.h"
 
 class TestFunctor : public Qt3DRender::QBufferDataGenerator
@@ -292,15 +291,13 @@ private Q_SLOTS:
 
         // WHEN
         TestArbiter arbiter;
-        Qt3DCore::QBackendNodePrivate::get(&backendBuffer)->setArbiter(&arbiter);
         backendBuffer.executeFunctor();
 
         // THEN
-        QCOMPARE(arbiter.events.count(), 0);
         QCOMPARE(backendBuffer.pendingBufferUpdates().size(), 1);
         QCOMPARE(backendBuffer.pendingBufferUpdates().first().offset, -1);
 
-        arbiter.events.clear();
+        arbiter.clear();
         backendBuffer.pendingBufferUpdates().clear();
 
         // WHEN
diff --git a/tests/auto/render/computecommand/tst_computecommand.cpp b/tests/auto/render/computecommand/tst_computecommand.cpp
index d6fa1d579..34a03b068 100644
--- a/tests/auto/render/computecommand/tst_computecommand.cpp
+++ b/tests/auto/render/computecommand/tst_computecommand.cpp
@@ -36,10 +36,9 @@
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <Qt3DCore/private/qaspectmanager_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include "qbackendnodetester.h"
 #include "testrenderer.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 
 class tst_ComputeCommand : public Qt3DCore::QBackendNodeTester
@@ -201,7 +200,6 @@ private Q_SLOTS:
     {
         // GIVEN
         TestRenderer renderer;
-        TestArbiter arbiter;
 
         Qt3DRender::QComputeCommand computeCommand;
         Qt3DRender::Render::ComputeCommand backendComputeCommand;
@@ -213,8 +211,6 @@ private Q_SLOTS:
         computeCommand.trigger(6);
 
 
-        Qt3DCore::QBackendNodePrivate::get(&backendComputeCommand)->setArbiter(&arbiter);
-
         backendComputeCommand.setRenderer(&renderer);
         simulateInitializationSync(&computeCommand, &backendComputeCommand);
 
@@ -226,7 +222,6 @@ private Q_SLOTS:
             QCOMPARE(backendComputeCommand.frameCount(), 6 - (i + 1));
             QCOMPARE(backendComputeCommand.isEnabled(), true);
             QCOMPARE(backendComputeCommand.hasReachedFrameCount(), false);
-            QCOMPARE(arbiter.events.size(), 0);
         }
 
         // WHEN
diff --git a/tests/auto/render/entity/tst_entity.cpp b/tests/auto/render/entity/tst_entity.cpp
index a762330dd..2408cac5b 100644
--- a/tests/auto/render/entity/tst_entity.cpp
+++ b/tests/auto/render/entity/tst_entity.cpp
@@ -26,10 +26,6 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QtTest>
 #include <Qt3DRender/private/entity_p.h>
 #include <Qt3DRender/private/entity_p_p.h>
diff --git a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
index a7cea2ef2..4aa7615be 100644
--- a/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
+++ b/tests/auto/render/framegraphnode/tst_framegraphnode.cpp
@@ -30,7 +30,6 @@
 #include <QtTest/QTest>
 #include <Qt3DRender/private/managers_p.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include "testrenderer.h"
 #include "qbackendnodetester.h"
 
diff --git a/tests/auto/render/geometry/tst_geometry.cpp b/tests/auto/render/geometry/tst_geometry.cpp
index a13f6fa40..9355f8339 100644
--- a/tests/auto/render/geometry/tst_geometry.cpp
+++ b/tests/auto/render/geometry/tst_geometry.cpp
@@ -35,10 +35,9 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DRender/private/geometry_p.h>
 #include <Qt3DRender/qgeometry.h>
 #include <Qt3DRender/qattribute.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include "testrenderer.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class DummyAttribute : public Qt3DRender::QAttribute
 {
@@ -199,23 +198,16 @@ private Q_SLOTS:
         TestArbiter arbiter;
         Qt3DRender::Render::Geometry renderGeometry;
 
-        Qt3DCore::QBackendNodePrivate::get(&renderGeometry)->setArbiter(&arbiter);
         renderGeometry.setRenderer(&renderer);
 
         // WHEN
         renderGeometry.updateExtent(QVector3D(-1.0f, -1.0f, -1.0f), QVector3D(1.0f, 1.0f, 1.0f));
-        renderGeometry.notifyExtentChanged();
 
         // THEN
-        QCOMPARE(arbiter.events.count(), 1);
+        QCOMPARE(arbiter.dirtyNodes().count(), 0);
 
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(change->propertyName(), "extent");
-        const QPair<QVector3D, QVector3D> v = change->value().value<QPair<QVector3D, QVector3D>>();
-        QCOMPARE(v.first, QVector3D(-1.0f, -1.0f, -1.0f));
-        QCOMPARE(v.second, QVector3D(1.0f, 1.0f, 1.0f));
-
-        arbiter.events.clear();
+        QCOMPARE(renderGeometry.min(), QVector3D(-1.0f, -1.0f, -1.0f));
+        QCOMPARE(renderGeometry.max(), QVector3D(1.0f, 1.0f, 1.0f));
     }
 };
 
diff --git a/tests/auto/render/joint/tst_joint.cpp b/tests/auto/render/joint/tst_joint.cpp
index 0388f4a80..c0b4a7a3b 100644
--- a/tests/auto/render/joint/tst_joint.cpp
+++ b/tests/auto/render/joint/tst_joint.cpp
@@ -35,7 +35,7 @@
 #include <QtGui/qmatrix4x4.h>
 #include <QtGui/qvector3d.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 #include <testrenderer.h>
 
 using namespace Qt3DCore;
diff --git a/tests/auto/render/levelofdetail/tst_levelofdetail.cpp b/tests/auto/render/levelofdetail/tst_levelofdetail.cpp
index 5005ca2d1..c0c06975a 100644
--- a/tests/auto/render/levelofdetail/tst_levelofdetail.cpp
+++ b/tests/auto/render/levelofdetail/tst_levelofdetail.cpp
@@ -33,7 +33,7 @@
 #include <Qt3DRender/private/levelofdetail_p.h>
 #include <Qt3DRender/private/qlevelofdetail_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 #include "testrenderer.h"
 
 class tst_LevelOfDetail : public Qt3DCore::QBackendNodeTester
diff --git a/tests/auto/render/loadscenejob/tst_loadscenejob.cpp b/tests/auto/render/loadscenejob/tst_loadscenejob.cpp
index 044c3e0f4..7e75f1d69 100644
--- a/tests/auto/render/loadscenejob/tst_loadscenejob.cpp
+++ b/tests/auto/render/loadscenejob/tst_loadscenejob.cpp
@@ -32,10 +32,9 @@
 #include <Qt3DRender/private/qsceneimporter_p.h>
 #include <Qt3DRender/private/nodemanagers_p.h>
 #include <Qt3DRender/private/scenemanager_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/QEntity>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class TestSceneImporter : public Qt3DRender::QSceneImporter
 {
@@ -139,7 +138,6 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(scene != nullptr);
-        Qt3DCore::QBackendNodePrivate::get(scene)->setArbiter(&arbiter);
 
         // WHEN
         Qt3DRender::Render::LoadSceneJob loadSceneJob(url, sceneId);
@@ -165,7 +163,6 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(scene != nullptr);
-        Qt3DCore::QBackendNodePrivate::get(scene)->setArbiter(&arbiter);
 
         // WHEN
         Qt3DRender::Render::LoadSceneJob loadSceneJob(url, sceneId);
@@ -194,7 +191,6 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(scene != nullptr);
-        Qt3DCore::QBackendNodePrivate::get(scene)->setArbiter(&arbiter);
 
         // WHEN
         Qt3DRender::Render::LoadSceneJob loadSceneJob(url, sceneId);
@@ -212,7 +208,6 @@ private Q_SLOTS:
     {
         // GIVEN
         const QUrl url(QStringLiteral("file:///URL"));
-        TestArbiter arbiter;
         Qt3DRender::Render::NodeManagers nodeManagers;
         TestSceneImporter fakeImporter(true, true);
         Qt3DCore::QNodeId sceneId = Qt3DCore::QNodeId::createId();
@@ -220,7 +215,6 @@ private Q_SLOTS:
 
         // THEN
         QVERIFY(scene != nullptr);
-        Qt3DCore::QBackendNodePrivate::get(scene)->setArbiter(&arbiter);
 
         // WHEN
         Qt3DRender::Render::LoadSceneJob loadSceneJob(url, sceneId);
diff --git a/tests/auto/render/objectpicker/tst_objectpicker.cpp b/tests/auto/render/objectpicker/tst_objectpicker.cpp
index 24fa2159d..0bbaffa84 100644
--- a/tests/auto/render/objectpicker/tst_objectpicker.cpp
+++ b/tests/auto/render/objectpicker/tst_objectpicker.cpp
@@ -32,7 +32,7 @@
 #include <Qt3DRender/qpickevent.h>
 #include <Qt3DRender/qobjectpicker.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 #include "testrenderer.h"
 
 class tst_ObjectPicker : public Qt3DCore::QBackendNodeTester
diff --git a/tests/auto/render/opengl/computecommand/tst_computecommand.cpp b/tests/auto/render/opengl/computecommand/tst_computecommand.cpp
index 3caf11c8f..bbe999ce8 100644
--- a/tests/auto/render/opengl/computecommand/tst_computecommand.cpp
+++ b/tests/auto/render/opengl/computecommand/tst_computecommand.cpp
@@ -36,11 +36,10 @@
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <Qt3DCore/private/qaspectmanager_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <renderer_p.h>
 #include "qbackendnodetester.h"
 #include "testrenderer.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 
 // tst_Renderer is a friend class of Renderer
@@ -68,7 +67,6 @@ private Q_SLOTS:
         // GIVEN
         Qt3DRender::Render::NodeManagers nodeManager;
         tst_Renderer renderer;
-        TestArbiter arbiter;
 
         Qt3DCore::QAspectManager manager;
         Qt3DCore::QScene scene;
@@ -100,7 +98,6 @@ private Q_SLOTS:
         computeCommand.setRunType(Qt3DRender::QComputeCommand::Manual);
         computeCommand.trigger(1);
 
-        Qt3DCore::QBackendNodePrivate::get(backendComputeCommand)->setArbiter(&arbiter);
         backendComputeCommand->setRenderer(&renderer);
         simulateInitializationSync(&computeCommand, backendComputeCommand);
 
diff --git a/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp b/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp
index 6a5bc87ea..c514cea82 100644
--- a/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp
+++ b/tests/auto/render/opengl/glshadermanager/tst_glshadermanager.cpp
@@ -55,8 +55,8 @@ void tst_GLShaderManager::adopt()
 
     backendShaderNode1.setRenderer(&renderer);
     backendShaderNode2.setRenderer(&renderer);
-    simulateInitialization(&frontendShader1, &backendShaderNode1);
-    simulateInitialization(&frontendShader2, &backendShaderNode2);
+    simulateInitializationSync(&frontendShader1, &backendShaderNode1);
+    simulateInitializationSync(&frontendShader2, &backendShaderNode2);
 
     // THEN
     QVERIFY(cache.lookupResource(backendShaderNode1.peerId()) == nullptr);
@@ -96,8 +96,8 @@ void tst_GLShaderManager::lookupResource()
 
     backendShaderNode1.setRenderer(&renderer);
     backendShaderNode2.setRenderer(&renderer);
-    simulateInitialization(&frontendShader1, &backendShaderNode1);
-    simulateInitialization(&frontendShader2, &backendShaderNode2);
+    simulateInitializationSync(&frontendShader1, &backendShaderNode1);
+    simulateInitializationSync(&frontendShader2, &backendShaderNode2);
 
     // WHEN
     cache.createOrAdoptExisting(&backendShaderNode1);
@@ -126,8 +126,8 @@ void tst_GLShaderManager::abandon()
 
     backendShaderNode1.setRenderer(&renderer);
     backendShaderNode2.setRenderer(&renderer);
-    simulateInitialization(&frontendShader1, &backendShaderNode1);
-    simulateInitialization(&frontendShader2, &backendShaderNode2);
+    simulateInitializationSync(&frontendShader1, &backendShaderNode1);
+    simulateInitializationSync(&frontendShader2, &backendShaderNode2);
     cache.createOrAdoptExisting(&backendShaderNode1);
     cache.createOrAdoptExisting(&backendShaderNode2);
 
@@ -162,7 +162,7 @@ void tst_GLShaderManager::insertAfterRemoval()
 
 
     backendShaderNode.setRenderer(&renderer);
-    simulateInitialization(&frontendShader, &backendShaderNode);
+    simulateInitializationSync(&frontendShader, &backendShaderNode);
 
     // WHEN
     Qt3DRender::Render::OpenGL::GLShader *apiShader1 = cache.createOrAdoptExisting(&backendShaderNode);
diff --git a/tests/auto/render/opengl/renderer/tst_renderer.cpp b/tests/auto/render/opengl/renderer/tst_renderer.cpp
index db7a37af1..c602e7cf8 100644
--- a/tests/auto/render/opengl/renderer/tst_renderer.cpp
+++ b/tests/auto/render/opengl/renderer/tst_renderer.cpp
@@ -95,8 +95,7 @@ private Q_SLOTS:
         QCOMPARE(jobs.size(),
                  1 + // PickBoundingVolumeJob
                  1 + // RayCastingJob
-                 1 + // SendBufferCaptureJob
-                 1); // SendSetFenceHandlesJob
+                 1); // SendBufferCaptureJob´
         // Note: pending set fence handles are only cleared when the job is run
 
         // Properly shutdown command thread
diff --git a/tests/auto/render/opengl/renderviews/tst_renderviews.cpp b/tests/auto/render/opengl/renderviews/tst_renderviews.cpp
index 6d01122d1..270034e1b 100644
--- a/tests/auto/render/opengl/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/opengl/renderviews/tst_renderviews.cpp
@@ -29,7 +29,7 @@
 #include <QtTest/QTest>
 #include <qbackendnodetester.h>
 #include <private/memorybarrier_p.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 #include <testrenderer.h>
 #include <private/shader_p.h>
 #include <Qt3DRender/qshaderprogram.h>
diff --git a/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp b/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp
index 6b714b9e1..add519b91 100644
--- a/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp
+++ b/tests/auto/render/opengl/renderviewutils/tst_renderviewutils.cpp
@@ -28,7 +28,6 @@
 
 #include <QtTest/QTest>
 #include <qbackendnodetester.h>
-#include <Qt3DCore/qdynamicpropertyupdatedchange.h>
 #include <renderviewjobutils_p.h>
 #include <shadervariables_p.h>
 #include <Qt3DRender/private/shaderdata_p.h>
@@ -36,7 +35,7 @@
 #include <Qt3DRender/private/stringtoint_p.h>
 #include <Qt3DRender/qshaderdata.h>
 #include "testrenderer.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_RenderViewUtils : public Qt3DCore::QBackendNodeTester
 {
@@ -79,7 +78,7 @@ private:
         // Create backend element for frontend one
         Qt3DRender::Render::Texture *backend = manager->getOrCreateResource(frontend->id());
         // Init the backend element
-        simulateInitialization(frontend, backend);
+        simulateInitializationSync(frontend, backend);
     }
 };
 
@@ -780,20 +779,18 @@ void tst_RenderViewUtils::shouldNotifyDynamicPropertyChanges()
     shaderData->setProperty("scalar", 883.0f);
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), shaderData.data());
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), shaderData.data());
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 
     // WHEN
     QScopedPointer<Qt3DRender::QAbstractTexture> texture(new Qt3DRender::QTexture2D);
     shaderData->setProperty("texture", QVariant::fromValue(texture.data()));
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), shaderData.data());
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), shaderData.data());
 }
 
 QTEST_MAIN(tst_RenderViewUtils)
diff --git a/tests/auto/render/opengl/textures/tst_textures.cpp b/tests/auto/render/opengl/textures/tst_textures.cpp
index 5343a6fde..5fb00f23d 100644
--- a/tests/auto/render/opengl/textures/tst_textures.cpp
+++ b/tests/auto/render/opengl/textures/tst_textures.cpp
@@ -644,7 +644,7 @@ private Q_SLOTS:
         // GIVEN
         Qt3DRender::QAbstractTexture* frontendTexture = createQTexture(1, {1}, true);
 
-        Qt3DRender::Render::Texture *backendTexture = static_cast<Qt3DRender::Render::Texture *>(textureBackendNodeMapper.create(creationChange(frontendTexture)));
+        Qt3DRender::Render::Texture *backendTexture = static_cast<Qt3DRender::Render::Texture *>(textureBackendNodeMapper.create(frontendTexture->id()));
         backendTexture->setRenderer(&renderer);
         simulateInitializationSync(frontendTexture, backendTexture);
 
@@ -678,7 +678,7 @@ private Q_SLOTS:
         // GIVEN
         Qt3DRender::QAbstractTexture* frontendTexture = createQTexture(1, {1}, true);
 
-        Qt3DRender::Render::Texture *backendTexture = static_cast<Qt3DRender::Render::Texture *>(textureBackendNodeMapper.create(creationChange(frontendTexture)));
+        Qt3DRender::Render::Texture *backendTexture = static_cast<Qt3DRender::Render::Texture *>(textureBackendNodeMapper.create(frontendTexture->id()));
         backendTexture->setRenderer(&renderer);
         simulateInitializationSync(frontendTexture, backendTexture);
 
@@ -691,7 +691,7 @@ private Q_SLOTS:
         QVERIFY(texMgr->lookupResource(frontendTexture->id()) == nullptr);
 
         // WHEN
-        backendTexture = static_cast<Qt3DRender::Render::Texture *>(textureBackendNodeMapper.create(creationChange(frontendTexture)));
+        backendTexture = static_cast<Qt3DRender::Render::Texture *>(textureBackendNodeMapper.create(frontendTexture->id()));
         backendTexture->setRenderer(&renderer);
         simulateInitializationSync(frontendTexture, backendTexture);
 
diff --git a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
index f1587c27c..c1ba2d981 100644
--- a/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
+++ b/tests/auto/render/pickboundingvolumejob/tst_pickboundingvolumejob.cpp
@@ -27,7 +27,7 @@
 ****************************************************************************/
 
 #include "qmlscenereader.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 #include <QtTest/QTest>
 #include <Qt3DCore/qentity.h>
@@ -797,7 +797,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id());
         QVERIFY(backendPicker1);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(test->arbiter());
 
         QCOMPARE(test->renderSettings()->pickMethod(), pickMethod);
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
@@ -929,7 +928,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id());
         QVERIFY(backendPicker1);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(&arbiter);
 
         QSignalSpy mouseButtonPressedSpy(picker1, &Qt3DRender::QObjectPicker::pressed);
         QSignalSpy mouseMovedSpy(picker1, &Qt3DRender::QObjectPicker::moved);
@@ -1038,7 +1036,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id());
         QVERIFY(backendPicker1);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(&arbiter);
 
         QCOMPARE(test->renderSettings()->pickMethod(), pickMethod);
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
@@ -1142,7 +1139,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->objectPickerManager()->lookupResource(picker->id());
         QVERIFY(backendPicker);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
 
         QCOMPARE(test->renderSettings()->pickMethod(), pickMethod);
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
@@ -1294,11 +1290,9 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id());
         QVERIFY(backendPicker1);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(&arbiter1);
 
         Qt3DRender::Render::ObjectPicker *backendPicker2 = test->nodeManagers()->objectPickerManager()->lookupResource(picker2->id());
         QVERIFY(backendPicker2);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker2)->setArbiter(&arbiter2);
 
         QCOMPARE(test->renderSettings()->pickMethod(), pickMethod);
         QCOMPARE(test->renderSettings()->pickResultMode(), pickResultMode);
@@ -1416,7 +1410,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->objectPickerManager()->lookupResource(picker->id());
         QVERIFY(backendPicker);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
 
         QSignalSpy mouseEntered(picker, &Qt3DRender::QObjectPicker::entered);
         QSignalSpy mouseExited(picker, &Qt3DRender::QObjectPicker::exited);
@@ -1486,7 +1479,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->objectPickerManager()->lookupResource(picker->id());
         QVERIFY(backendPicker);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
 
         QSignalSpy mouseEntered(picker, &Qt3DRender::QObjectPicker::entered);
         QSignalSpy mouseExited(picker, &Qt3DRender::QObjectPicker::exited);
@@ -1605,7 +1597,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker = test->nodeManagers()->objectPickerManager()->lookupResource(picker->id());
         QVERIFY(backendPicker);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker)->setArbiter(&arbiter);
 
         QSignalSpy mouseEntered(picker, &Qt3DRender::QObjectPicker::entered);
         QSignalSpy mouseExited(picker, &Qt3DRender::QObjectPicker::exited);
@@ -1674,11 +1665,9 @@ private Q_SLOTS:
 
         Qt3DRender::Render::ObjectPicker *backendPicker1 = test->nodeManagers()->objectPickerManager()->lookupResource(picker1->id());
         QVERIFY(backendPicker1);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker1)->setArbiter(&arbiter1);
 
         Qt3DRender::Render::ObjectPicker *backendPicker2 = test->nodeManagers()->objectPickerManager()->lookupResource(picker2->id());
         QVERIFY(backendPicker2);
-        Qt3DCore::QBackendNodePrivate::get(backendPicker2)->setArbiter(&arbiter2);
 
         QSignalSpy mouseEntered1(picker1, &Qt3DRender::QObjectPicker::entered);
         QSignalSpy mouseExited1(picker1, &Qt3DRender::QObjectPicker::exited);
diff --git a/tests/auto/render/picking/tst_picking.cpp b/tests/auto/render/picking/tst_picking.cpp
index b281eb6cb..d9800c24f 100644
--- a/tests/auto/render/picking/tst_picking.cpp
+++ b/tests/auto/render/picking/tst_picking.cpp
@@ -29,7 +29,6 @@
 #include <QtTest/QtTest>
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qtransform.h>
-#include <Qt3DCore/QPropertyUpdatedChange>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DRender/private/qboundingvolumeprovider_p.h>
 #include <Qt3DRender/private/pickboundingvolumejob_p.h>
@@ -55,11 +54,6 @@ public:
     MyObjectPicker(Qt3DCore::QNode *parent = nullptr)
         : Qt3DRender::QObjectPicker(parent)
     {}
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) final
-    {
-        Qt3DRender::QObjectPicker::sceneChangeEvent(change);
-    }
 };
 
 class PickableEntity : public QEntity
diff --git a/tests/auto/render/qabstractlight/tst_qabstractlight.cpp b/tests/auto/render/qabstractlight/tst_qabstractlight.cpp
index 011ad1036..7c2162ecf 100644
--- a/tests/auto/render/qabstractlight/tst_qabstractlight.cpp
+++ b/tests/auto/render/qabstractlight/tst_qabstractlight.cpp
@@ -29,7 +29,6 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qabstractlight.h>
 #include <Qt3DRender/private/qabstractlight_p.h>
@@ -40,7 +39,7 @@
 #include <Qt3DRender/private/qdirectionallight_p.h>
 #include <Qt3DRender/private/qspotlight_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class DummyLight : public Qt3DRender::QAbstractLight
 {
@@ -60,87 +59,6 @@ class tst_QAbstractLight: public Qt3DCore::QNode
     Q_OBJECT
 
 private Q_SLOTS:
-    // TO DO: Test should be rewritten to query the properties from the attached QShaderData
-
-//    void checkLightCloning()
-//    {
-//        // GIVEN
-//        DummyLight light;
-//        light.setColor(Qt::red);
-//        light.setIntensity(0.5f);
-
-//        // WHEN
-//        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(material);
-//        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-//        // THEN
-//        QVERIFY(creationChanges.size() >= 1);
-
-//        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QA> creationChangeData =
-//                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QMaterialData>>(creationChanges.first());
-//        const Qt3DRender::QMaterialData &cloneData = creationChangeData->data;
-
-
-//        QScopedPointer<Qt3DRender::QAbstractLight> lightClone(static_cast<Qt3DRender::QAbstractLight *>(QNode::clone(&light)));
-//        QVERIFY(lightClone.data());
-//        QCOMPARE(light.color(), lightClone->color());
-//        QCOMPARE(light.intensity(), lightClone->intensity());
-//    }
-
-//    void checkPointLightCloning()
-//    {
-//        Qt3DRender::QPointLight pointLight;
-//        QCOMPARE(pointLight.type(), Qt3DRender::QAbstractLight::PointLight);
-//        pointLight.setColor(Qt::green);
-//        pointLight.setIntensity(0.5f);
-//        pointLight.setConstantAttenuation(0.5f);
-//        pointLight.setLinearAttenuation(0.0f);      // No actual event triggered as 0.0f is default
-//        pointLight.setQuadraticAttenuation(1.0f);
-
-//        QScopedPointer<Qt3DRender::QPointLight> pointLightClone(static_cast<Qt3DRender::QPointLight *>(QNode::clone(&pointLight)));
-//        QVERIFY(pointLightClone.data());
-//        QCOMPARE(pointLightClone->type(), Qt3DRender::QAbstractLight::PointLight);
-//        QCOMPARE(pointLight.color(), pointLightClone->color());
-//        QCOMPARE(pointLight.intensity(), pointLightClone->intensity());
-//        QCOMPARE(pointLight.constantAttenuation(), pointLightClone->constantAttenuation());
-//        QCOMPARE(pointLight.linearAttenuation(), pointLightClone->linearAttenuation());
-//        QCOMPARE(pointLight.quadraticAttenuation(), pointLightClone->quadraticAttenuation());
-//    }
-
-//    void checkDirectionalLightCloning()
-//    {
-//        Qt3DRender::QDirectionalLight dirLight;
-//        QCOMPARE(dirLight.type(), Qt3DRender::QAbstractLight::DirectionalLight);
-//        dirLight.setColor(Qt::blue);
-//        dirLight.setIntensity(0.5f);
-//        dirLight.setWorldDirection(QVector3D(0, 0, -1));
-
-//        QScopedPointer<Qt3DRender::QDirectionalLight> dirLightClone(static_cast<Qt3DRender::QDirectionalLight *>(QNode::clone(&dirLight)));
-//        QVERIFY(dirLightClone.data());
-//        QCOMPARE(dirLightClone->type(), Qt3DRender::QAbstractLight::DirectionalLight);
-//        QCOMPARE(dirLight.color(), dirLightClone->color());
-//        QCOMPARE(dirLight.intensity(), dirLightClone->intensity());
-//        QCOMPARE(dirLight.worldDirection(), dirLightClone->worldDirection());
-//    }
-
-//    void checkSpotLightCloning()
-//    {
-//        Qt3DRender::QSpotLight spotLight;
-//        QCOMPARE(spotLight.type(), Qt3DRender::QAbstractLight::SpotLight);
-//        spotLight.setColor(Qt::lightGray);
-//        spotLight.setIntensity(0.5f);
-//        spotLight.setLocalDirection(QVector3D(0, 0, -1));
-//        spotLight.setCutOffAngle(0.75f);
-
-//        QScopedPointer<Qt3DRender::QSpotLight> spotLightClone(static_cast<Qt3DRender::QSpotLight *>(QNode::clone(&spotLight)));
-//        QVERIFY(spotLightClone.data());
-//        QCOMPARE(spotLightClone->type(), Qt3DRender::QAbstractLight::SpotLight);
-//        QCOMPARE(spotLight.color(), spotLightClone->color());
-//        QCOMPARE(spotLight.intensity(), spotLightClone->intensity());
-//        QCOMPARE(spotLight.localDirection(), spotLightClone->localDirection());
-//        QCOMPARE(spotLight.cutOffAngle(), spotLightClone->cutOffAngle());
-//    }
-
     void checkLightPropertyUpdates()
     {
         TestArbiter arbiter;
@@ -150,16 +68,11 @@ private Q_SLOTS:
         light->setColor(Qt::red);
         light->setIntensity(0.8f); // change from the default of 0.5f
 
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 2);
-        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
-        QCOMPARE(arbiter.dirtyNodes[1], light.data());
-
-        arbiter.dirtyNodes.clear();
-
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 2);
+        QVERIFY(arbiter.dirtyNodes()[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes()[1], light.data());
 
-        arbiter.events.clear();
+        arbiter.clear();
     }
 
     void checkPointLightPropertyUpdates()
@@ -174,12 +87,11 @@ private Q_SLOTS:
         pointLight->setLinearAttenuation(0.0f);     // No actual event triggered as 0.0f is default
         pointLight->setQuadraticAttenuation(1.0f);
 
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 2);
-        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
-        QCOMPARE(arbiter.dirtyNodes[1], pointLight.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 2);
+        QVERIFY(arbiter.dirtyNodes()[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes()[1], pointLight.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkDirectionalLightPropertyUpdates()
@@ -192,11 +104,11 @@ private Q_SLOTS:
         dirLight->setIntensity(0.8f);
         dirLight->setWorldDirection(QVector3D(0.5f, 0.0f, -1.0f));
 
-        QCOMPARE(arbiter.dirtyNodes.size(), 2);
-        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
-        QCOMPARE(arbiter.dirtyNodes[1], dirLight.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 2);
+        QVERIFY(arbiter.dirtyNodes()[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes()[1], dirLight.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkSpotLightPropertyUpdates()
@@ -210,11 +122,11 @@ private Q_SLOTS:
         spotLight->setLocalDirection(QVector3D(0.5f, 0.0f, -1.0f));
         spotLight->setCutOffAngle(0.75f);
 
-        QCOMPARE(arbiter.dirtyNodes.size(), 2);
-        QVERIFY(arbiter.dirtyNodes[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
-        QCOMPARE(arbiter.dirtyNodes[1], spotLight.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 2);
+        QVERIFY(arbiter.dirtyNodes()[0]->metaObject()->inherits(&Qt3DRender::QShaderData::staticMetaObject));
+        QCOMPARE(arbiter.dirtyNodes()[1], spotLight.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 };
 
diff --git a/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
index 6fad09a0d..99048fbc2 100644
--- a/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
+++ b/tests/auto/render/qabstracttexture/tst_qabstracttexture.cpp
@@ -26,23 +26,14 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
 #include <Qt3DRender/qabstracttexture.h>
 #include <Qt3DRender/private/qabstracttexture_p.h>
 #include <QObject>
 #include <QSignalSpy>
 #include <Qt3DRender/qabstracttextureimage.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class FakeTexture : public Qt3DRender::QAbstractTexture
 {
@@ -51,12 +42,6 @@ public:
     {
         return static_cast<Qt3DRender::QAbstractTexturePrivate *>(d_ptr.get())->m_sharedTextureId;
     }
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) override
-    {
-        Qt3DRender::QAbstractTexture::sceneChangeEvent(change);
-    }
-
 };
 
 class FakeTextureImage : public Qt3DRender::QAbstractTextureImage
@@ -347,117 +332,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        FakeTexture abstractTexture;
-
-        abstractTexture.setFormat(Qt3DRender::QAbstractTexture::RG3B2);
-        abstractTexture.setGenerateMipMaps(true);
-        abstractTexture.setWidth(350);
-        abstractTexture.setHeight(383);
-        abstractTexture.setDepth(396);
-        abstractTexture.setMagnificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
-        abstractTexture.setMinificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapNearest);
-        abstractTexture.setMaximumAnisotropy(12.0f);
-        abstractTexture.setComparisonFunction(Qt3DRender::QAbstractTexture::CommpareNotEqual);
-        abstractTexture.setComparisonMode(Qt3DRender::QAbstractTexture::CompareRefToTexture);
-        abstractTexture.setLayers(128);
-        abstractTexture.setSamples(256);
-        abstractTexture.setWrapMode(Qt3DRender::QTextureWrapMode(Qt3DRender::QTextureWrapMode::ClampToBorder));
-
-        FakeTextureImage image;
-        FakeTextureImage image2;
-        abstractTexture.addTextureImage(&image);
-        abstractTexture.addTextureImage(&image2);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTexture);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // Texture + Images
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureData cloneData = creationChangeData->data;
-
-            QCOMPARE(abstractTexture.target(), cloneData.target);
-            QCOMPARE(abstractTexture.format(), cloneData.format);
-            QCOMPARE(abstractTexture.generateMipMaps(), cloneData.autoMipMap);
-            QCOMPARE(abstractTexture.wrapMode()->x(), cloneData.wrapModeX);
-            QCOMPARE(abstractTexture.wrapMode()->x(), cloneData.wrapModeY);
-            QCOMPARE(abstractTexture.wrapMode()->x(), cloneData.wrapModeZ);
-            QCOMPARE(abstractTexture.width(), cloneData.width);
-            QCOMPARE(abstractTexture.height(), cloneData.height);
-            QCOMPARE(abstractTexture.depth(), cloneData.depth);
-            QCOMPARE(abstractTexture.magnificationFilter(), cloneData.magFilter);
-            QCOMPARE(abstractTexture.minificationFilter(), cloneData.minFilter);
-            QCOMPARE(abstractTexture.maximumAnisotropy(), cloneData.maximumAnisotropy);
-            QCOMPARE(abstractTexture.comparisonFunction(), cloneData.comparisonFunction);
-            QCOMPARE(abstractTexture.comparisonMode(), cloneData.comparisonMode);
-            QCOMPARE(abstractTexture.layers(), cloneData.layers);
-            QCOMPARE(abstractTexture.samples(), cloneData.samples);
-            QCOMPARE(abstractTexture.sharedTextureId(), cloneData.sharedTextureId);
-            QCOMPARE(abstractTexture.textureImages().size(), cloneData.textureImageIds.size());
-
-            for (int i = 0, m = abstractTexture.textureImages().size(); i < m; ++i)
-                QCOMPARE(abstractTexture.textureImages().at(i)->id(), cloneData.textureImageIds.at(i));
-
-            QCOMPARE(abstractTexture.id(), creationChangeData->subjectId());
-            QCOMPARE(abstractTexture.isEnabled(), true);
-            QCOMPARE(abstractTexture.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(abstractTexture.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        abstractTexture.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTexture);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // Texture + Images
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureData cloneData = creationChangeData->data;
-
-            QCOMPARE(abstractTexture.target(), cloneData.target);
-            QCOMPARE(abstractTexture.format(), cloneData.format);
-            QCOMPARE(abstractTexture.generateMipMaps(), cloneData.autoMipMap);
-            QCOMPARE(abstractTexture.wrapMode()->x(), cloneData.wrapModeX);
-            QCOMPARE(abstractTexture.wrapMode()->x(), cloneData.wrapModeY);
-            QCOMPARE(abstractTexture.wrapMode()->x(), cloneData.wrapModeZ);
-            QCOMPARE(abstractTexture.width(), cloneData.width);
-            QCOMPARE(abstractTexture.height(), cloneData.height);
-            QCOMPARE(abstractTexture.depth(), cloneData.depth);
-            QCOMPARE(abstractTexture.magnificationFilter(), cloneData.magFilter);
-            QCOMPARE(abstractTexture.minificationFilter(), cloneData.minFilter);
-            QCOMPARE(abstractTexture.maximumAnisotropy(), cloneData.maximumAnisotropy);
-            QCOMPARE(abstractTexture.comparisonFunction(), cloneData.comparisonFunction);
-            QCOMPARE(abstractTexture.comparisonMode(), cloneData.comparisonMode);
-            QCOMPARE(abstractTexture.layers(), cloneData.layers);
-            QCOMPARE(abstractTexture.samples(), cloneData.samples);
-            QCOMPARE(abstractTexture.sharedTextureId(), cloneData.sharedTextureId);
-            QCOMPARE(abstractTexture.textureImages().size(), cloneData.textureImageIds.size());
-
-            for (int i = 0, m = abstractTexture.textureImages().size(); i < m; ++i)
-                QCOMPARE(abstractTexture.textureImages().at(i)->id(), cloneData.textureImageIds.at(i));
-
-            QCOMPARE(abstractTexture.id(), creationChangeData->subjectId());
-            QCOMPARE(abstractTexture.isEnabled(), false);
-            QCOMPARE(abstractTexture.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(abstractTexture.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkFormatUpdate()
     {
         // GIVEN
@@ -470,11 +344,10 @@ private Q_SLOTS:
             abstractTexture.setFormat(Qt3DRender::QAbstractTexture::RG8_UNorm);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -482,8 +355,7 @@ private Q_SLOTS:
             abstractTexture.setFormat(Qt3DRender::QAbstractTexture::RG8_UNorm);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -500,11 +372,10 @@ private Q_SLOTS:
             abstractTexture.setGenerateMipMaps(true);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -512,8 +383,7 @@ private Q_SLOTS:
             abstractTexture.setGenerateMipMaps(true);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -530,11 +400,10 @@ private Q_SLOTS:
             abstractTexture.setWidth(1024);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -542,8 +411,7 @@ private Q_SLOTS:
             abstractTexture.setWidth(1024);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -560,11 +428,10 @@ private Q_SLOTS:
             abstractTexture.setHeight(256);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -572,8 +439,7 @@ private Q_SLOTS:
             abstractTexture.setHeight(256);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -590,11 +456,10 @@ private Q_SLOTS:
             abstractTexture.setDepth(512);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -602,8 +467,7 @@ private Q_SLOTS:
             abstractTexture.setDepth(512);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -620,11 +484,10 @@ private Q_SLOTS:
             abstractTexture.setMagnificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -632,8 +495,7 @@ private Q_SLOTS:
             abstractTexture.setMagnificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -650,11 +512,10 @@ private Q_SLOTS:
             abstractTexture.setMinificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -662,8 +523,7 @@ private Q_SLOTS:
             abstractTexture.setMinificationFilter(Qt3DRender::QAbstractTexture::NearestMipMapLinear);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -680,11 +540,10 @@ private Q_SLOTS:
             abstractTexture.setMaximumAnisotropy(327.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -692,8 +551,7 @@ private Q_SLOTS:
             abstractTexture.setMaximumAnisotropy(327.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -710,11 +568,10 @@ private Q_SLOTS:
             abstractTexture.setComparisonFunction(Qt3DRender::QAbstractTexture::CompareAlways);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -722,8 +579,7 @@ private Q_SLOTS:
             abstractTexture.setComparisonFunction(Qt3DRender::QAbstractTexture::CompareAlways);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -740,11 +596,10 @@ private Q_SLOTS:
             abstractTexture.setComparisonMode(Qt3DRender::QAbstractTexture::CompareRefToTexture);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -752,8 +607,7 @@ private Q_SLOTS:
             abstractTexture.setComparisonMode(Qt3DRender::QAbstractTexture::CompareRefToTexture);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -770,11 +624,10 @@ private Q_SLOTS:
             abstractTexture.setLayers(64);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -782,8 +635,7 @@ private Q_SLOTS:
             abstractTexture.setLayers(64);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -800,11 +652,10 @@ private Q_SLOTS:
             abstractTexture.setSamples(16);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -812,8 +663,7 @@ private Q_SLOTS:
             abstractTexture.setSamples(16);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -832,11 +682,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 
@@ -855,11 +704,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 
@@ -874,143 +722,6 @@ private Q_SLOTS:
         qRegisterMetaType<Qt3DRender::QAbstractTexture::TextureFormat>("TextureFormat");
         qRegisterMetaType<Qt3DRender::QAbstractTexture::HandleType>("HandleType");
 
-
-        {
-            QSignalSpy spy(&abstractTexture, SIGNAL(widthChanged(int)));
-
-            // THEN
-            QVERIFY(spy.isValid());
-
-            // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("width");
-            valueChange->setValue(883);
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.width(), 883);
-
-            // WHEN
-            spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.width(), 883);
-        }
-
-        {
-            QSignalSpy spy(&abstractTexture, SIGNAL(heightChanged(int)));
-
-            // THEN
-            QVERIFY(spy.isValid());
-
-            // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("height");
-            valueChange->setValue(1584);
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.height(), 1584);
-
-            // WHEN
-            spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.height(), 1584);
-        }
-
-        {
-            QSignalSpy spy(&abstractTexture, SIGNAL(depthChanged(int)));
-
-            // THEN
-            QVERIFY(spy.isValid());
-
-            // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("depth");
-            valueChange->setValue(8);
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.depth(), 8);
-
-            // WHEN
-            spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.depth(), 8);
-        }
-
-        {
-            QSignalSpy spy(&abstractTexture, SIGNAL(layersChanged(int)));
-
-            // THEN
-            QVERIFY(spy.isValid());
-
-            // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("layers");
-            valueChange->setValue(256);
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.layers(), 256);
-
-            // WHEN
-            spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.layers(), 256);
-        }
-
-        {
-            QSignalSpy spy(&abstractTexture, SIGNAL(formatChanged(TextureFormat)));
-
-            // THEN
-            QVERIFY(spy.isValid());
-
-            // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("format");
-            const auto newFormat = Qt3DRender::QAbstractTexture::R8I;
-            valueChange->setValue(QVariant::fromValue(newFormat));
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.format(), newFormat);
-
-            // WHEN
-            spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
-
-            // THEN
-            QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(abstractTexture.format(), newFormat);
-        }
-
         {
             QSignalSpy spy(&abstractTexture, SIGNAL(statusChanged(Status)));
 
@@ -1018,24 +729,23 @@ private Q_SLOTS:
             QVERIFY(spy.isValid());
 
             // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("status");
+            auto *dTexture = static_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DCore::QNodePrivate::get(&abstractTexture));
             const auto newStatus = Qt3DRender::QAbstractTexture::Error;
-            valueChange->setValue(QVariant::fromValue(newStatus));
-            abstractTexture.sceneChangeEvent(valueChange);
+            dTexture->setStatus(newStatus);
 
             // THEN
             QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
             QCOMPARE(abstractTexture.status(), newStatus);
 
             // WHEN
             spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
+            arbiter.clear();
+            dTexture->setStatus(newStatus);
 
             // THEN
             QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
             QCOMPARE(abstractTexture.status(), newStatus);
         }
 
@@ -1046,24 +756,23 @@ private Q_SLOTS:
             QVERIFY(spy.isValid());
 
             // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("handleType");
+            auto *dTexture = static_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DCore::QNodePrivate::get(&abstractTexture));
             const auto newType = Qt3DRender::QAbstractTexture::OpenGLTextureId;
-            valueChange->setValue(QVariant::fromValue(newType));
-            abstractTexture.sceneChangeEvent(valueChange);
+            dTexture->setHandleType(newType);
 
             // THEN
             QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
             QCOMPARE(abstractTexture.handleType(), newType);
 
             // WHEN
             spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
+            arbiter.clear();
+            dTexture->setHandleType(newType);
 
             // THEN
             QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
             QCOMPARE(abstractTexture.handleType(), newType);
         }
 
@@ -1074,23 +783,21 @@ private Q_SLOTS:
             QVERIFY(spy.isValid());
 
             // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("handle");
-            valueChange->setValue(QVariant(1));
-            abstractTexture.sceneChangeEvent(valueChange);
+            auto *dTexture = static_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DCore::QNodePrivate::get(&abstractTexture));
+            dTexture->setHandle(QVariant(1));
 
             // THEN
             QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
             QCOMPARE(abstractTexture.handle(), QVariant(1));
 
             // WHEN
             spy.clear();
-            abstractTexture.sceneChangeEvent(valueChange);
+            arbiter.clear();
+            dTexture->setHandle(QVariant(1));
 
             // THEN
             QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
             QCOMPARE(abstractTexture.handle(), QVariant(1));
         }
     }
@@ -1111,8 +818,8 @@ private Q_SLOTS:
             // THEN (arbiter -> should not be stored in the initial changes but only send as a property change)
             auto d = static_cast<Qt3DRender::QAbstractTexturePrivate*>(Qt3DRender::QAbstractTexturePrivate::get(&abstractTexture));
             QCOMPARE(d->m_pendingDataUpdates.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTexture);
         }
     }
 
diff --git a/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp b/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp
index 6bd742dad..8ea482ceb 100644
--- a/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp
+++ b/tests/auto/render/qabstracttextureimage/tst_qabstracttextureimage.cpp
@@ -32,9 +32,7 @@
 #include <Qt3DRender/private/qabstracttextureimage_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class FakeTextureImage : public Qt3DRender::QAbstractTextureImage
 {
@@ -131,64 +129,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        FakeTextureImage abstractTextureImage;
-
-        abstractTextureImage.setMipLevel(32);
-        abstractTextureImage.setLayer(56);
-        abstractTextureImage.setFace(Qt3DRender::QAbstractTexture::CubeMapNegativeY);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTextureImage);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureImageData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureImageData cloneData = creationChangeData->data;
-
-            QCOMPARE(abstractTextureImage.mipLevel(), cloneData.mipLevel);
-            QCOMPARE(abstractTextureImage.layer(), cloneData.layer);
-            QCOMPARE(abstractTextureImage.face(), cloneData.face);
-            QCOMPARE(abstractTextureImage.id(), creationChangeData->subjectId());
-            QCOMPARE(abstractTextureImage.isEnabled(), true);
-            QCOMPARE(abstractTextureImage.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(abstractTextureImage.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        abstractTextureImage.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&abstractTextureImage);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureImageData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureImageData cloneData = creationChangeData->data;
-
-            QCOMPARE(abstractTextureImage.mipLevel(), cloneData.mipLevel);
-            QCOMPARE(abstractTextureImage.layer(), cloneData.layer);
-            QCOMPARE(abstractTextureImage.face(), cloneData.face);
-            QCOMPARE(abstractTextureImage.id(), creationChangeData->subjectId());
-            QCOMPARE(abstractTextureImage.isEnabled(), false);
-            QCOMPARE(abstractTextureImage.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(abstractTextureImage.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkMipLevelUpdate()
     {
         // GIVEN
@@ -201,10 +141,10 @@ private Q_SLOTS:
             abstractTextureImage.setMipLevel(9);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTextureImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTextureImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -212,7 +152,7 @@ private Q_SLOTS:
             abstractTextureImage.setMipLevel(9);
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -229,11 +169,10 @@ private Q_SLOTS:
             abstractTextureImage.setLayer(12);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTextureImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTextureImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -241,8 +180,7 @@ private Q_SLOTS:
             abstractTextureImage.setLayer(12);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -259,11 +197,10 @@ private Q_SLOTS:
             abstractTextureImage.setFace(Qt3DRender::QAbstractTexture::CubeMapPositiveY);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &abstractTextureImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &abstractTextureImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -271,8 +208,7 @@ private Q_SLOTS:
             abstractTextureImage.setFace(Qt3DRender::QAbstractTexture::CubeMapPositiveY);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qattribute/tst_qattribute.cpp b/tests/auto/render/qattribute/tst_qattribute.cpp
index 588ce40db..44793ce9f 100644
--- a/tests/auto/render/qattribute/tst_qattribute.cpp
+++ b/tests/auto/render/qattribute/tst_qattribute.cpp
@@ -29,13 +29,12 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/QAttribute>
 #include <Qt3DRender/private/qattribute_p.h>
 #include <Qt3DRender/QBuffer>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QAttribute: public QObject
 {
@@ -77,80 +76,6 @@ private Q_SLOTS:
                  Qt3DRender::QAttribute::defaultJointWeightsAttributeName());
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QAttribute *>("attribute");
-
-        Qt3DRender::QAttribute *defaultConstructed = new Qt3DRender::QAttribute();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DRender::QAttribute *customVertex = new Qt3DRender::QAttribute();
-        Qt3DRender::QBuffer *buffer = new Qt3DRender::QBuffer();
-        customVertex->setBuffer(buffer);
-        customVertex->setAttributeType(Qt3DRender::QAttribute::VertexAttribute);
-        customVertex->setCount(454);
-        customVertex->setByteStride(427);
-        customVertex->setByteOffset(305);
-        customVertex->setDivisor(235);
-        customVertex->setName("BB");
-        customVertex->setVertexBaseType(Qt3DRender::QAttribute::Float);
-        customVertex->setVertexSize(4);
-        QTest::newRow("vertex") << customVertex;
-
-        Qt3DRender::QAttribute *customIndex = new Qt3DRender::QAttribute();
-        Qt3DRender::QBuffer *indexBuffer = new Qt3DRender::QBuffer();
-        customIndex->setBuffer(indexBuffer);
-        customIndex->setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
-        customIndex->setCount(383);
-        customIndex->setByteStride(350);
-        customIndex->setByteOffset(327);
-        customIndex->setDivisor(355);
-        customIndex->setName("SB");
-        customIndex->setVertexBaseType(Qt3DRender::QAttribute::Float);
-        customIndex->setVertexSize(3);
-        QTest::newRow("index") << customIndex;
-
-        Qt3DRender::QAttribute *customIndirect = new Qt3DRender::QAttribute();
-        Qt3DRender::QBuffer *indirectBuffer = new Qt3DRender::QBuffer();
-        customIndirect->setBuffer(indirectBuffer);
-        customIndirect->setAttributeType(Qt3DRender::QAttribute::DrawIndirectAttribute);
-        customIndirect->setCount(1);
-        customIndirect->setByteStride(12);
-        customIndirect->setByteOffset(0);
-        customIndirect->setName("DrawIndirect");
-        QTest::newRow("index") << customIndirect;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QAttribute *, attribute);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(attribute);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (attribute->buffer() ? 1 : 0));
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QAttributeData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAttributeData>>(creationChanges.first());
-        const Qt3DRender::QAttributeData &cloneData = creationChangeData->data;
-
-        QCOMPARE(attribute->id(), creationChangeData->subjectId());
-        QCOMPARE(attribute->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(attribute->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(attribute->name(), cloneData.name);
-        QCOMPARE(attribute->count(), cloneData.count);
-        QCOMPARE(attribute->byteStride(), cloneData.byteStride);
-        QCOMPARE(attribute->byteOffset(), cloneData.byteOffset);
-        QCOMPARE(attribute->divisor(), cloneData.divisor);
-        QCOMPARE(attribute->vertexBaseType(), cloneData.vertexBaseType);
-        QCOMPARE(attribute->vertexSize(), cloneData.vertexSize);
-        QVERIFY(attribute->attributeType() == cloneData.attributeType);
-        QCOMPARE(attribute->buffer() ? attribute->buffer()->id() : Qt3DCore::QNodeId(), cloneData.bufferId);
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -162,93 +87,93 @@ private Q_SLOTS:
         attribute->setVertexBaseType(Qt3DRender::QAttribute::Double);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         attribute->setVertexSize(4);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         attribute->setName(QStringLiteral("Duntov"));
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         attribute->setCount(883);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         attribute->setByteStride(1340);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         attribute->setByteOffset(1584);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         attribute->setDivisor(1450);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         attribute->setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QBuffer buf;
         attribute->setBuffer(&buf);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QBuffer buf2;
         attribute->setBuffer(&buf2);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), attribute.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), attribute.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkBufferBookkeeping()
diff --git a/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp b/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp
index a53650945..2ff8a35ee 100644
--- a/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp
+++ b/tests/auto/render/qblitframebuffer/tst_qblitframebuffer.cpp
@@ -29,12 +29,11 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/QBlitFramebuffer>
 #include <Qt3DRender/private/qblitframebuffer_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QBlitFrameBuffer: public QObject
 {
@@ -75,37 +74,6 @@ private Q_SLOTS:
         QCOMPARE(blitFramebuffer.interpolationMethod(), Qt3DRender::QBlitFramebuffer::Linear);
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QBlitFramebuffer *, blitFramebuffer);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(blitFramebuffer);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 3); // 3 due to automatic parenting
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QBlitFramebufferData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QBlitFramebufferData>>(creationChanges.first());
-        const Qt3DRender::QBlitFramebufferData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(blitFramebuffer->id(), creationChangeData->subjectId());
-        QCOMPARE(blitFramebuffer->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(blitFramebuffer->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(blitFramebuffer->source()->id(), cloneData.m_sourceRenderTargetId);
-        QCOMPARE(blitFramebuffer->destination()->id(), cloneData.m_destinationRenderTargetId);
-        QCOMPARE(blitFramebuffer->sourceRect(), cloneData.m_sourceRect);
-        QCOMPARE(blitFramebuffer->destinationRect(), cloneData.m_destinationRect);
-        QCOMPARE(blitFramebuffer->sourceAttachmentPoint(), cloneData.m_sourceAttachmentPoint);
-        QCOMPARE(blitFramebuffer->destinationAttachmentPoint(), cloneData.m_destinationAttachmentPoint);
-
-
-        delete blitFramebuffer;
-    }
-
     void checkPropertyUpdate()
     {
         // GIVEN
@@ -121,167 +89,149 @@ private Q_SLOTS:
         blitFramebuffer->setSource(sourceRenderTarget);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         blitFramebuffer->setSource(sourceRenderTarget);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         blitFramebuffer->setSource(nullptr);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // destinationRenderTarget
         // WHEN
         blitFramebuffer->setDestination(destinationRenderTarget);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         blitFramebuffer->setDestination(destinationRenderTarget);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         blitFramebuffer->setDestination(nullptr);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // sourceRect
         // WHEN
         blitFramebuffer->setSourceRect(QRect(0,0,1,1));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         blitFramebuffer->setSourceRect(QRect(0,0,1,1));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         blitFramebuffer->setSourceRect(QRect());
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // destinationRect
         blitFramebuffer->setDestinationRect(QRect(0,0,1,1));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         blitFramebuffer->setDestinationRect(QRect(0,0,1,1));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         blitFramebuffer->setDestinationRect(QRect());
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // sourceAttachmentPoint
         // WHEN
         blitFramebuffer->setSourceAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         blitFramebuffer->setSourceAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         blitFramebuffer->setSourceAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color0);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // destinationAttachmentPoint
         // WHEN
         blitFramebuffer->setDestinationAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         blitFramebuffer->setDestinationAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color1);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         blitFramebuffer->setDestinationAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color0);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), blitFramebuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), blitFramebuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkSourceDestReset()
diff --git a/tests/auto/render/qbuffer/tst_qbuffer.cpp b/tests/auto/render/qbuffer/tst_qbuffer.cpp
index fd96bf1c2..cbb141d2e 100644
--- a/tests/auto/render/qbuffer/tst_qbuffer.cpp
+++ b/tests/auto/render/qbuffer/tst_qbuffer.cpp
@@ -33,13 +33,12 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qbuffer.h>
 #include <Qt3DRender/private/qbuffer_p.h>
 #include <Qt3DRender/qbufferdatagenerator.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class TestFunctor : public Qt3DRender::QBufferDataGenerator
 {
@@ -73,58 +72,6 @@ class tst_QBuffer: public QObject
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QBuffer *>("buffer");
-
-        Qt3DRender::QBuffer *defaultConstructed = new Qt3DRender::QBuffer();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        auto buffer = new Qt3DRender::QBuffer;
-        buffer->setUsage(Qt3DRender::QBuffer::DynamicRead);
-        buffer->setData(QByteArrayLiteral("There's no replacement"));
-        buffer->setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(883)));
-        QTest::newRow("vertex") << buffer;
-
-        auto indexBuffer = new Qt3DRender::QBuffer;
-        indexBuffer->setUsage(Qt3DRender::QBuffer::StaticCopy);
-        indexBuffer->setData(QByteArrayLiteral("For displacement"));
-        indexBuffer->setDataGenerator(Qt3DRender::QBufferDataGeneratorPtr(new TestFunctor(1340)));
-        indexBuffer->setSyncData(true);
-        QTest::newRow("index") << indexBuffer;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QBuffer *, buffer);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(buffer);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QBufferData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QBufferData>>(creationChanges.first());
-        const Qt3DRender::QBufferData &cloneData = creationChangeData->data;
-
-
-        QCOMPARE(buffer->id(), creationChangeData->subjectId());
-        QCOMPARE(buffer->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(buffer->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(buffer->data(), cloneData.data);
-        QCOMPARE(buffer->usage(), cloneData.usage);
-        QCOMPARE(buffer->dataGenerator(), cloneData.functor);
-        QCOMPARE(buffer->isSyncData(), cloneData.syncData);
-        if (buffer->dataGenerator()) {
-            QVERIFY(cloneData.functor);
-            QVERIFY(*cloneData.functor == *buffer->dataGenerator());
-            QCOMPARE((*cloneData.functor)(), (*buffer->dataGenerator())());
-        }
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -136,21 +83,19 @@ private Q_SLOTS:
         buffer->setUsage(Qt3DRender::QBuffer::DynamicCopy);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), buffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         buffer->setData(QByteArrayLiteral("Z28"));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), buffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QBufferDataGeneratorPtr functor(new TestFunctor(355));
@@ -158,28 +103,27 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), buffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         buffer->setSyncData(true);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), buffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         buffer->updateData(1, QByteArrayLiteral("L1"));
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), buffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), buffer.data());
     }
 };
 
diff --git a/tests/auto/render/qcamera/tst_qcamera.cpp b/tests/auto/render/qcamera/tst_qcamera.cpp
index fae8aa14e..ee217d38c 100644
--- a/tests/auto/render/qcamera/tst_qcamera.cpp
+++ b/tests/auto/render/qcamera/tst_qcamera.cpp
@@ -36,7 +36,6 @@
 #include <Qt3DCore/QEntity>
 #include <Qt3DCore/private/qaspectjobmanager_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
 #include <Qt3DCore/qtransform.h>
 
 #include <Qt3DRender/qcamera.h>
diff --git a/tests/auto/render/qcameralens/tst_qcameralens.cpp b/tests/auto/render/qcameralens/tst_qcameralens.cpp
index 131c3a9d5..241515d7b 100644
--- a/tests/auto/render/qcameralens/tst_qcameralens.cpp
+++ b/tests/auto/render/qcameralens/tst_qcameralens.cpp
@@ -32,9 +32,7 @@
 #include <Qt3DRender/private/qcameralens_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QCameraLens : public QObject
 {
@@ -351,64 +349,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QCameraLens cameraLens;
-
-        cameraLens.setNearPlane(0.5);
-        cameraLens.setFarPlane(1005.0f);
-        cameraLens.setFieldOfView(35.0f);
-        cameraLens.setAspectRatio(16.0f/9.0f);
-        cameraLens.setExposure(1.0f);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&cameraLens);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QCameraLensData>>(creationChanges.first());
-            const Qt3DRender::QCameraLensData cloneData = creationChangeData->data;
-
-            QCOMPARE(cameraLens.projectionMatrix(), cloneData.projectionMatrix);
-            QCOMPARE(cameraLens.exposure(), cloneData.exposure);
-            QCOMPARE(cameraLens.id(), creationChangeData->subjectId());
-            QCOMPARE(cameraLens.isEnabled(), true);
-            QCOMPARE(cameraLens.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(cameraLens.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        cameraLens.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&cameraLens);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QCameraLensData>>(creationChanges.first());
-            const Qt3DRender::QCameraLensData cloneData = creationChangeData->data;
-
-            QCOMPARE(cameraLens.projectionMatrix(), cloneData.projectionMatrix);
-            QCOMPARE(cameraLens.exposure(), cloneData.exposure);
-            QCOMPARE(cameraLens.id(), creationChangeData->subjectId());
-            QCOMPARE(cameraLens.isEnabled(), false);
-            QCOMPARE(cameraLens.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(cameraLens.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkProjectionTypeUpdate()
     {
         // GIVEN
@@ -422,11 +362,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -435,8 +374,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -453,11 +391,10 @@ private Q_SLOTS:
             cameraLens.setNearPlane(5.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -465,8 +402,7 @@ private Q_SLOTS:
             cameraLens.setNearPlane(5.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -483,11 +419,10 @@ private Q_SLOTS:
             cameraLens.setFarPlane(5.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -495,8 +430,7 @@ private Q_SLOTS:
             cameraLens.setFarPlane(5.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -513,11 +447,10 @@ private Q_SLOTS:
             cameraLens.setFieldOfView(5.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -525,8 +458,7 @@ private Q_SLOTS:
             cameraLens.setFieldOfView(5.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -543,11 +475,10 @@ private Q_SLOTS:
             cameraLens.setAspectRatio(9.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -555,8 +486,7 @@ private Q_SLOTS:
             cameraLens.setAspectRatio(9.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -573,11 +503,10 @@ private Q_SLOTS:
             cameraLens.setLeft(0.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -585,8 +514,7 @@ private Q_SLOTS:
             cameraLens.setLeft(0.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -603,11 +531,10 @@ private Q_SLOTS:
             cameraLens.setRight(24.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -615,8 +542,7 @@ private Q_SLOTS:
             cameraLens.setRight(24.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -633,11 +559,10 @@ private Q_SLOTS:
             cameraLens.setBottom(-12.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -645,8 +570,7 @@ private Q_SLOTS:
             cameraLens.setBottom(-12.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -663,11 +587,10 @@ private Q_SLOTS:
             cameraLens.setTop(12.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -675,8 +598,7 @@ private Q_SLOTS:
             cameraLens.setTop(12.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -693,11 +615,10 @@ private Q_SLOTS:
             cameraLens.setExposure(2.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -705,8 +626,7 @@ private Q_SLOTS:
             cameraLens.setExposure(2.0f);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -726,11 +646,10 @@ private Q_SLOTS:
             cameraLens.setProjectionMatrix(m);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &cameraLens);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &cameraLens);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -738,8 +657,7 @@ private Q_SLOTS:
             cameraLens.setProjectionMatrix(m);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qcameraselector/tst_qcameraselector.cpp b/tests/auto/render/qcameraselector/tst_qcameraselector.cpp
index 650e531c2..9b70887fe 100644
--- a/tests/auto/render/qcameraselector/tst_qcameraselector.cpp
+++ b/tests/auto/render/qcameraselector/tst_qcameraselector.cpp
@@ -29,13 +29,11 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qcameraselector.h>
 #include <Qt3DRender/private/qcameraselector_p.h>
 #include <Qt3DCore/qentity.h>
-
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_QCameraSelector: public QObject
 {
@@ -43,45 +41,6 @@ class tst_QCameraSelector: public QObject
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QCameraSelector *>("cameraSelector");
-        QTest::addColumn<Qt3DCore::QEntity *>("camera");
-
-        Qt3DRender::QCameraSelector *defaultConstructed = new Qt3DRender::QCameraSelector();
-        QTest::newRow("defaultConstructed") << defaultConstructed << static_cast<Qt3DCore::QEntity *>(nullptr);
-
-        Qt3DRender::QCameraSelector *selector1 = new Qt3DRender::QCameraSelector();
-        Qt3DCore::QEntity *camera1 = new Qt3DCore::QEntity();
-        QTest::newRow("valid camera") << selector1 << camera1;
-        selector1->setCamera(camera1);
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QCameraSelector *, cameraSelector);
-        QFETCH(Qt3DCore::QEntity *, camera);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(cameraSelector);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (camera ? 1 : 0));
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QCameraSelectorData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QCameraSelectorData>>(creationChanges.first());
-        const Qt3DRender::QCameraSelectorData &cloneData = creationChangeData->data;
-
-        QCOMPARE(cameraSelector->id(), creationChangeData->subjectId());
-        QCOMPARE(cameraSelector->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(cameraSelector->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(cameraSelector->camera() ? cameraSelector->camera()->id() : Qt3DCore::QNodeId(), cloneData.cameraId);
-
-        delete cameraSelector;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -94,39 +53,35 @@ private Q_SLOTS:
         cameraSelector->setCamera(camera);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), cameraSelector.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), cameraSelector.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         cameraSelector->setCamera(camera);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         Qt3DCore::QEntity *camera2 = new Qt3DCore::QEntity();
         cameraSelector->setCamera(camera2);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), cameraSelector.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), cameraSelector.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         cameraSelector->setCamera(nullptr);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), cameraSelector.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), cameraSelector.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkCameraBookkeeping()
diff --git a/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp b/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp
index d2407229d..787b6540a 100644
--- a/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp
+++ b/tests/auto/render/qclearbuffers/tst_qclearbuffers.cpp
@@ -29,12 +29,10 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qclearbuffers.h>
 #include <Qt3DRender/private/qclearbuffers_p.h>
-
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 class tst_QClearBuffers: public QObject
 {
@@ -42,59 +40,6 @@ class tst_QClearBuffers: public QObject
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QClearBuffers *>("clearBuffers");
-        QTest::addColumn<Qt3DRender::QClearBuffers::BufferType>("bufferType");
-
-        Qt3DRender::QClearBuffers *defaultConstructed = new Qt3DRender::QClearBuffers();
-        QTest::newRow("defaultConstructed") << defaultConstructed << Qt3DRender::QClearBuffers::None;
-
-        Qt3DRender::QClearBuffers *allBuffers = new Qt3DRender::QClearBuffers();
-        allBuffers->setBuffers(Qt3DRender::QClearBuffers::AllBuffers);
-        QTest::newRow("allBuffers") << allBuffers << Qt3DRender::QClearBuffers::AllBuffers;
-
-        Qt3DRender::QClearBuffers *depthBuffer = new Qt3DRender::QClearBuffers();
-        depthBuffer->setBuffers(Qt3DRender::QClearBuffers::DepthBuffer);
-        QTest::newRow("depthBuffer") << depthBuffer << Qt3DRender::QClearBuffers::DepthBuffer;
-
-        Qt3DRender::QClearBuffers *colorDepthBuffer = new Qt3DRender::QClearBuffers();
-        colorDepthBuffer->setBuffers(Qt3DRender::QClearBuffers::ColorDepthBuffer);
-        QTest::newRow("colorDepthBuffer") << colorDepthBuffer << Qt3DRender::QClearBuffers::ColorDepthBuffer;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QClearBuffers *, clearBuffers);
-        QFETCH(Qt3DRender::QClearBuffers::BufferType, bufferType);
-
-        // THEN
-        QCOMPARE(clearBuffers->buffers(), bufferType);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(clearBuffers);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QClearBuffersData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QClearBuffersData>>(creationChanges.first());
-        const Qt3DRender::QClearBuffersData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(clearBuffers->id(), creationChangeData->subjectId());
-        QCOMPARE(clearBuffers->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(clearBuffers->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(clearBuffers->buffers(), cloneData.buffersType);
-        QCOMPARE(clearBuffers->clearColor(), cloneData.clearColor);
-        QCOMPARE(clearBuffers->clearDepthValue(), cloneData.clearDepthValue);
-        QCOMPARE(clearBuffers->clearStencilValue(), cloneData.clearStencilValue);
-
-        delete clearBuffers;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -106,28 +51,25 @@ private Q_SLOTS:
         clearBuffer->setBuffers(Qt3DRender::QClearBuffers::AllBuffers);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), clearBuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), clearBuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         clearBuffer->setBuffers(Qt3DRender::QClearBuffers::AllBuffers);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         clearBuffer->setBuffers(Qt3DRender::QClearBuffers::ColorDepthBuffer);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), clearBuffer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), clearBuffer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 };
 
diff --git a/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp b/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp
index 505229d5c..202cbbf5e 100644
--- a/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp
+++ b/tests/auto/render/qcomputecommand/tst_qcomputecommand.cpp
@@ -32,9 +32,7 @@
 #include <Qt3DRender/private/qcomputecommand_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QComputeCommand : public QObject
 {
@@ -137,69 +135,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QComputeCommand computeCommand;
-
-        computeCommand.setWorkGroupX(128);
-        computeCommand.setWorkGroupY(512);
-        computeCommand.setWorkGroupZ(1024);
-        computeCommand.setRunType(Qt3DRender::QComputeCommand::Manual);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&computeCommand);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QComputeCommandData>>(creationChanges.first());
-            const Qt3DRender::QComputeCommandData cloneData = creationChangeData->data;
-
-            QCOMPARE(computeCommand.workGroupX(), cloneData.workGroupX);
-            QCOMPARE(computeCommand.workGroupY(), cloneData.workGroupY);
-            QCOMPARE(computeCommand.workGroupZ(), cloneData.workGroupZ);
-            QCOMPARE(computeCommand.runType(), cloneData.runType);
-            QCOMPARE(0, cloneData.frameCount);
-            QCOMPARE(computeCommand.id(), creationChangeData->subjectId());
-            QCOMPARE(computeCommand.isEnabled(), true);
-            QCOMPARE(computeCommand.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(computeCommand.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        computeCommand.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&computeCommand);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QComputeCommandData>>(creationChanges.first());
-            const Qt3DRender::QComputeCommandData cloneData = creationChangeData->data;
-
-            QCOMPARE(computeCommand.workGroupX(), cloneData.workGroupX);
-            QCOMPARE(computeCommand.workGroupY(), cloneData.workGroupY);
-            QCOMPARE(computeCommand.workGroupZ(), cloneData.workGroupZ);
-            QCOMPARE(computeCommand.id(), creationChangeData->subjectId());
-            QCOMPARE(computeCommand.isEnabled(), false);
-            QCOMPARE(computeCommand.runType(), cloneData.runType);
-            QCOMPARE(0, cloneData.frameCount);
-            QCOMPARE(computeCommand.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(computeCommand.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkWorkGroupXUpdate()
     {
         // GIVEN
@@ -213,11 +148,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &computeCommand);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -226,7 +160,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -243,11 +177,10 @@ private Q_SLOTS:
             computeCommand.setWorkGroupY(512);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &computeCommand);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -255,8 +188,7 @@ private Q_SLOTS:
             computeCommand.setWorkGroupY(512);
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -274,11 +206,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &computeCommand);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -287,8 +218,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -306,11 +236,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &computeCommand);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -319,8 +248,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -333,7 +261,7 @@ private Q_SLOTS:
         computeCommand.setRunType(Qt3DRender::QComputeCommand::Manual);
         computeCommand.setEnabled(false);
         QCoreApplication::processEvents();
-        arbiter.events.clear();
+        arbiter.clear();
 
         {
             // WHEN
@@ -341,14 +269,13 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &computeCommand);
             QCOMPARE(computeCommand.isEnabled(), true);
 
             computeCommand.setEnabled(false);
             QCoreApplication::processEvents();
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -357,15 +284,13 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &computeCommand);
             QCOMPARE(computeCommand.isEnabled(), true);
 
             computeCommand.setEnabled(false);
             QCoreApplication::processEvents();
-            arbiter.events.clear();
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -374,16 +299,15 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &computeCommand);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &computeCommand);
             QCOMPARE(computeCommand.isEnabled(), true);
             QCOMPARE(computeCommand.workGroupX(), 10);
             QCOMPARE(computeCommand.workGroupY(), 11);
             QCOMPARE(computeCommand.workGroupZ(), 12);
 
             computeCommand.setEnabled(false);
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 
diff --git a/tests/auto/render/qdefaultmeshes/qdefaultmeshes.pro b/tests/auto/render/qdefaultmeshes/qdefaultmeshes.pro
deleted file mode 100644
index aaf49b892..000000000
--- a/tests/auto/render/qdefaultmeshes/qdefaultmeshes.pro
+++ /dev/null
@@ -1,12 +0,0 @@
-TEMPLATE = app
-
-TARGET = tst_qdefaultmeshes
-
-QT += core-private 3dcore 3dcore-private 3drender 3drender-private testlib 3dextras
-
-CONFIG += testcase
-
-SOURCES += \
-    tst_qdefaultmeshes.cpp
-
-include(../commons/commons.pri)
diff --git a/tests/auto/render/qdefaultmeshes/tst_qdefaultmeshes.cpp b/tests/auto/render/qdefaultmeshes/tst_qdefaultmeshes.cpp
deleted file mode 100644
index 8c64a005a..000000000
--- a/tests/auto/render/qdefaultmeshes/tst_qdefaultmeshes.cpp
+++ /dev/null
@@ -1,111 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the Qt3D module of the Qt Toolkit.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
-
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
-#include <QtTest/QTest>
-
-#include <Qt3DRender/qgeometryrenderer.h>
-#include <Qt3DRender/qgeometryfactory.h>
-#include <Qt3DRender/qgeometry.h>
-#include <Qt3DRender/qattribute.h>
-#include <Qt3DRender/qbuffer.h>
-#include <Qt3DRender/qbufferdatagenerator.h>
-#include <Qt3DRender/private/qgeometryrenderer_p.h>
-#include <Qt3DRender/private/qgeometry_p.h>
-#include <Qt3DRender/private/qattribute_p.h>
-#include <Qt3DRender/private/qbuffer_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-
-#include <Qt3DExtras/qspheremesh.h>
-#include <Qt3DExtras/qcylindermesh.h>
-#include <Qt3DExtras/qtorusmesh.h>
-#include <Qt3DExtras/qcuboidmesh.h>
-#include <Qt3DExtras/qplanemesh.h>
-
-
-class tst_QDefaultMeshes: public QObject
-{
-    Q_OBJECT
-
-public:
-    tst_QDefaultMeshes()
-    {
-        qRegisterMetaType<Qt3DCore::QNode*>();
-    }
-
-private Q_SLOTS:
-
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QGeometryRenderer *>("geomRenderer");
-        QTest::newRow("QSphereMesh") << static_cast<Qt3DRender::QGeometryRenderer *>(new Qt3DExtras::QSphereMesh);
-        QTest::newRow("QCylinderMesh") << static_cast<Qt3DRender::QGeometryRenderer *>(new Qt3DExtras::QCylinderMesh);
-        QTest::newRow("QTorusMesh") << static_cast<Qt3DRender::QGeometryRenderer *>(new Qt3DExtras::QTorusMesh);
-        QTest::newRow("QCuboidMesh") << static_cast<Qt3DRender::QGeometryRenderer *>(new Qt3DExtras::QCuboidMesh);
-        QTest::newRow("QPlaneMesh") << static_cast<Qt3DRender::QGeometryRenderer *>(new Qt3DExtras::QPlaneMesh);
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QGeometryRenderer *, geomRenderer);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(geomRenderer);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QVERIFY(creationChanges.size() >= 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QGeometryRendererData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QGeometryRendererData>>(creationChanges.first());
-        const Qt3DRender::QGeometryRendererData &cloneData = creationChangeData->data;
-
-        QCOMPARE(creationChangeData->subjectId(), geomRenderer->id());
-        QCOMPARE(cloneData.instanceCount, geomRenderer->instanceCount());
-        QCOMPARE(cloneData.vertexCount, geomRenderer->vertexCount());
-        QCOMPARE(cloneData.indexOffset, geomRenderer->indexOffset());
-        QCOMPARE(cloneData.firstInstance, geomRenderer->firstInstance());
-        QCOMPARE(cloneData.restartIndexValue, geomRenderer->restartIndexValue());
-        QCOMPARE(cloneData.primitiveRestart, geomRenderer->primitiveRestartEnabled());
-        QCOMPARE(cloneData.primitiveType, geomRenderer->primitiveType());
-        QCOMPARE(cloneData.geometryFactory, geomRenderer->geometryFactory());
-
-        if (geomRenderer->geometryFactory()) {
-            QVERIFY(cloneData.geometryFactory);
-            QVERIFY(*cloneData.geometryFactory == *geomRenderer->geometryFactory());
-        }
-    }
-};
-
-QTEST_MAIN(tst_QDefaultMeshes)
-
-#include "tst_qdefaultmeshes.moc"
diff --git a/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp b/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp
index c4bed3a83..f54edf8c2 100644
--- a/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp
+++ b/tests/auto/render/qdispatchcompute/tst_qdispatchcompute.cpp
@@ -32,9 +32,7 @@
 #include <Qt3DRender/private/qdispatchcompute_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QDispatchCompute : public QObject
 {
@@ -117,64 +115,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QDispatchCompute dispatchCompute;
-
-        dispatchCompute.setWorkGroupX(427);
-        dispatchCompute.setWorkGroupY(454);
-        dispatchCompute.setWorkGroupZ(383);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&dispatchCompute);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QDispatchComputeData>>(creationChanges.first());
-            const Qt3DRender::QDispatchComputeData cloneData = creationChangeData->data;
-
-            QCOMPARE(dispatchCompute.workGroupX(), cloneData.workGroupX);
-            QCOMPARE(dispatchCompute.workGroupY(), cloneData.workGroupY);
-            QCOMPARE(dispatchCompute.workGroupZ(), cloneData.workGroupZ);
-            QCOMPARE(dispatchCompute.id(), creationChangeData->subjectId());
-            QCOMPARE(dispatchCompute.isEnabled(), true);
-            QCOMPARE(dispatchCompute.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(dispatchCompute.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        dispatchCompute.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&dispatchCompute);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QDispatchComputeData>>(creationChanges.first());
-            const Qt3DRender::QDispatchComputeData cloneData = creationChangeData->data;
-
-            QCOMPARE(dispatchCompute.workGroupX(), cloneData.workGroupX);
-            QCOMPARE(dispatchCompute.workGroupY(), cloneData.workGroupY);
-            QCOMPARE(dispatchCompute.workGroupZ(), cloneData.workGroupZ);
-            QCOMPARE(dispatchCompute.id(), creationChangeData->subjectId());
-            QCOMPARE(dispatchCompute.isEnabled(), false);
-            QCOMPARE(dispatchCompute.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(dispatchCompute.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkWorkGroupXUpdate()
     {
         // GIVEN
@@ -188,11 +128,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &dispatchCompute);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &dispatchCompute);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -201,8 +140,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -220,11 +158,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &dispatchCompute);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &dispatchCompute);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -233,8 +170,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -252,11 +188,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &dispatchCompute);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &dispatchCompute);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -265,8 +200,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qeffect/tst_qeffect.cpp b/tests/auto/render/qeffect/tst_qeffect.cpp
index cc4889b8f..f7e43186d 100644
--- a/tests/auto/render/qeffect/tst_qeffect.cpp
+++ b/tests/auto/render/qeffect/tst_qeffect.cpp
@@ -34,9 +34,7 @@
 #include <Qt3DRender/private/qeffect_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QEffect : public QObject
 {
@@ -101,67 +99,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QEffect effect;
-
-        Qt3DRender::QParameter parameter;
-        effect.addParameter(&parameter);
-        Qt3DRender::QTechnique technique;
-        effect.addTechnique(&technique);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&effect);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // Effect + Parameter + Technique
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QEffectData>>(creationChanges.first());
-            const Qt3DRender::QEffectData cloneData = creationChangeData->data;
-
-            QCOMPARE(cloneData.parameterIds.size(), 1);
-            QCOMPARE(parameter.id(), cloneData.parameterIds.first());
-            QCOMPARE(cloneData.techniqueIds.size(), 1);
-            QCOMPARE(technique.id(), cloneData.techniqueIds.first());
-            QCOMPARE(effect.id(), creationChangeData->subjectId());
-            QCOMPARE(effect.isEnabled(), true);
-            QCOMPARE(effect.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(effect.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        effect.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&effect);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 3); // Effect + Parameter + Technique
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QEffectData>>(creationChanges.first());
-            const Qt3DRender::QEffectData cloneData = creationChangeData->data;
-
-            QCOMPARE(cloneData.parameterIds.size(), 1);
-            QCOMPARE(parameter.id(), cloneData.parameterIds.first());
-            QCOMPARE(cloneData.techniqueIds.size(), 1);
-            QCOMPARE(technique.id(), cloneData.techniqueIds.first());
-            QCOMPARE(effect.id(), creationChangeData->subjectId());
-            QCOMPARE(effect.isEnabled(), false);
-            QCOMPARE(effect.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(effect.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkParameterBookkeeping()
     {
         // GIVEN
@@ -214,8 +151,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &effect);
             QVERIFY(effect.parameters().contains(&parameter));
+            arbiter.clear();
         }
 
         {
@@ -224,8 +163,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &effect);
             QVERIFY(!effect.parameters().contains(&parameter));
+            arbiter.clear();
         }
 
     }
@@ -244,10 +185,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &effect);
-            arbiter.dirtyNodes.clear();
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &effect);
+            arbiter.clear();
         }
 
         {
@@ -256,10 +196,9 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &effect);
-            arbiter.dirtyNodes.clear();
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &effect);
+            arbiter.clear();
         }
 
     }
diff --git a/tests/auto/render/qenvironmentlight/tst_qenvironmentlight.cpp b/tests/auto/render/qenvironmentlight/tst_qenvironmentlight.cpp
index 97375b647..5eab3a005 100644
--- a/tests/auto/render/qenvironmentlight/tst_qenvironmentlight.cpp
+++ b/tests/auto/render/qenvironmentlight/tst_qenvironmentlight.cpp
@@ -34,9 +34,7 @@
 #include <Qt3DRender/private/qenvironmentlight_p.h>
 #include <Qt3DRender/private/qshaderdata_p.h>
 
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QEnvironmentLight: public QObject
 {
@@ -341,57 +339,6 @@ private Q_SLOTS:
                      QVector3D());
         }
     }
-
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QEnvironmentLight light;
-        auto shaderData = light.findChild<Qt3DRender::QShaderData*>();
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&light);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // EnvironmentLight + ShaderData
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QEnvironmentLightData>>(creationChanges.first());
-            const Qt3DRender::QEnvironmentLightData cloneData = creationChangeData->data;
-
-            QCOMPARE(cloneData.shaderDataId, shaderData->id());
-            QCOMPARE(light.id(), creationChangeData->subjectId());
-            QCOMPARE(light.isEnabled(), true);
-            QCOMPARE(light.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(light.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        light.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&light);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // EnvironmentLight + ShaderData
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QEnvironmentLightData>>(creationChanges.first());
-            const Qt3DRender::QEnvironmentLightData cloneData = creationChangeData->data;
-
-            QCOMPARE(cloneData.shaderDataId, shaderData->id());
-            QCOMPARE(light.id(), creationChangeData->subjectId());
-            QCOMPARE(light.isEnabled(), false);
-            QCOMPARE(light.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(light.metaObject(), creationChangeData->metaObject());
-        }
-    }
 };
 
 QTEST_MAIN(tst_QEnvironmentLight)
diff --git a/tests/auto/render/qfilterkey/tst_qfilterkey.cpp b/tests/auto/render/qfilterkey/tst_qfilterkey.cpp
index f4c31c89e..4e7fe581a 100644
--- a/tests/auto/render/qfilterkey/tst_qfilterkey.cpp
+++ b/tests/auto/render/qfilterkey/tst_qfilterkey.cpp
@@ -32,9 +32,7 @@
 #include <Qt3DRender/private/qfilterkey_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QFilterKey : public QObject
 {
@@ -97,61 +95,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QFilterKey filterKey;
-
-        filterKey.setValue(QVariant(QStringLiteral("Taylor")));
-        filterKey.setName(QStringLiteral("Craig"));
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&filterKey);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QFilterKeyData>>(creationChanges.first());
-            const Qt3DRender::QFilterKeyData cloneData = creationChangeData->data;
-
-            QCOMPARE(filterKey.value(), cloneData.value);
-            QCOMPARE(filterKey.name(), cloneData.name);
-            QCOMPARE(filterKey.id(), creationChangeData->subjectId());
-            QCOMPARE(filterKey.isEnabled(), true);
-            QCOMPARE(filterKey.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(filterKey.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        filterKey.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&filterKey);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QFilterKeyData>>(creationChanges.first());
-            const Qt3DRender::QFilterKeyData cloneData = creationChangeData->data;
-
-            QCOMPARE(filterKey.value(), cloneData.value);
-            QCOMPARE(filterKey.name(), cloneData.name);
-            QCOMPARE(filterKey.id(), creationChangeData->subjectId());
-            QCOMPARE(filterKey.isEnabled(), false);
-            QCOMPARE(filterKey.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(filterKey.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkValueUpdate()
     {
         // GIVEN
@@ -165,11 +108,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &filterKey);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &filterKey);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -178,8 +120,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -197,11 +138,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &filterKey);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &filterKey);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -210,8 +150,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp b/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp
index 6116e031e..4c11a9258 100644
--- a/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp
+++ b/tests/auto/render/qframegraphnode/tst_qframegraphnode.cpp
@@ -30,14 +30,11 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qframegraphnode.h>
 #include <Qt3DRender/private/qframegraphnode_p.h>
-#include <Qt3DRender/qframegraphnodecreatedchange.h>
-#include <Qt3DRender/private/qframegraphnodecreatedchange_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MyFrameGraphNode : public Qt3DRender::QFrameGraphNode
 {
@@ -63,112 +60,6 @@ private Q_SLOTS:
         QVERIFY(defaultFrameGraphNode->parentFrameGraphNode() == nullptr);
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QFrameGraphNode *>("frameGraphNode");
-        QTest::addColumn<QVector<Qt3DCore::QNodeId>>("childFrameGraphNodeIds");
-        QTest::addColumn<bool>("enabled");
-        QTest::addColumn<int>("creationChangeCount");
-
-        QVector<Qt3DCore::QNodeId> noChildIds;
-
-        {
-            Qt3DRender::QFrameGraphNode *defaultConstructed = new MyFrameGraphNode();
-            QTest::newRow("defaultConstructed") << defaultConstructed << noChildIds << true << 1;
-        }
-
-        {
-            Qt3DRender::QFrameGraphNode *disabledFrameGraphNode = new MyFrameGraphNode();
-            disabledFrameGraphNode->setEnabled(false);
-            QTest::newRow("allBuffers") << disabledFrameGraphNode << noChildIds << false << 1;
-        }
-
-        {
-            Qt3DRender::QFrameGraphNode *nodeWithChildren = new MyFrameGraphNode();
-            Qt3DRender::QFrameGraphNode *child1 = new MyFrameGraphNode(nodeWithChildren);
-            Qt3DRender::QFrameGraphNode *child2 = new MyFrameGraphNode(nodeWithChildren);
-            QVector<Qt3DCore::QNodeId> childIds = {child1->id(), child2->id()};
-            QTest::newRow("nodeWithChildren") << nodeWithChildren << childIds << true << 3;
-        }
-
-        {
-            Qt3DRender::QFrameGraphNode *nodeWithNestedChildren = new MyFrameGraphNode();
-            Qt3DRender::QFrameGraphNode *child = new MyFrameGraphNode(nodeWithNestedChildren);
-            new Qt3DCore::QNode(nodeWithNestedChildren);
-            Qt3DRender::QFrameGraphNode *grandChild = new MyFrameGraphNode(nodeWithNestedChildren);
-            QVector<Qt3DCore::QNodeId> childIds = {child->id(), grandChild->id()};
-            QTest::newRow("nodeWithNestedChildren") << nodeWithNestedChildren << childIds << true << 4;
-        }
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QFrameGraphNode *, frameGraphNode);
-        QFETCH(QVector<Qt3DCore::QNodeId>, childFrameGraphNodeIds);
-        QFETCH(bool, enabled);
-        QFETCH(int, creationChangeCount);
-
-        // THEN
-        QCOMPARE(frameGraphNode->isEnabled(), enabled);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(frameGraphNode);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), creationChangeCount);
-        const Qt3DCore::QNodeCreatedChangeBasePtr creationChangeData = creationChanges.first();
-
-        // THEN
-        QCOMPARE(frameGraphNode->id(), creationChangeData->subjectId());
-        QCOMPARE(frameGraphNode->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(frameGraphNode->metaObject(), creationChangeData->metaObject());
-
-        // THEN
-        Qt3DRender::QFrameGraphNodeCreatedChangeBasePtr frameGraphNodeCreatedChange = qSharedPointerCast<Qt3DRender::QFrameGraphNodeCreatedChangeBase>(creationChangeData);
-        Qt3DRender::QFrameGraphNodeCreatedChangeBasePrivate *creationChangeDataPrivate = Qt3DRender::QFrameGraphNodeCreatedChangeBasePrivate::get(frameGraphNodeCreatedChange.get());
-        QCOMPARE(creationChangeDataPrivate->m_parentFrameGraphNodeId, frameGraphNode->parentNode() ? frameGraphNode->parentNode()->id() : Qt3DCore::QNodeId());
-        QCOMPARE(creationChangeDataPrivate->m_childFrameGraphNodeIds, childFrameGraphNodeIds);
-
-        delete frameGraphNode;
-    }
-
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QFrameGraphNode *parentFrameGraphNode = new MyFrameGraphNode();
-        Qt3DRender::QFrameGraphNode *childFrameGraphNode = new MyFrameGraphNode(parentFrameGraphNode);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(parentFrameGraphNode);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        {
-            // THEN
-            QCOMPARE(creationChanges.size(), 2);
-            {
-
-                const auto creationChangeData = qSharedPointerCast<Qt3DRender::QFrameGraphNodeCreatedChangeBase>(creationChanges.first());
-                QCOMPARE(parentFrameGraphNode->isEnabled(), creationChangeData->isNodeEnabled());
-                QCOMPARE(parentFrameGraphNode->metaObject(), creationChangeData->metaObject());
-                QCOMPARE(Qt3DCore::qIdForNode(parentFrameGraphNode->parentFrameGraphNode()), creationChangeData->parentFrameGraphNodeId());
-            }
-            // THEN
-            {
-                const auto creationChangeData = qSharedPointerCast<Qt3DRender::QFrameGraphNodeCreatedChangeBase>(creationChanges.last());
-                QCOMPARE(childFrameGraphNode->isEnabled(), creationChangeData->isNodeEnabled());
-                QCOMPARE(childFrameGraphNode->metaObject(), creationChangeData->metaObject());
-                QCOMPARE(Qt3DCore::qIdForNode(childFrameGraphNode->parentFrameGraphNode()), parentFrameGraphNode->id());
-                QCOMPARE(Qt3DCore::qIdForNode(childFrameGraphNode->parentFrameGraphNode()), creationChangeData->parentFrameGraphNodeId());
-            }
-        }
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -181,30 +72,27 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), frameGraphNode.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), frameGraphNode.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         frameGraphNode->setEnabled(false);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         frameGraphNode->setEnabled(true);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), frameGraphNode.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), frameGraphNode.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkParentFrameNodeRetrieval()
diff --git a/tests/auto/render/qgeometry/tst_qgeometry.cpp b/tests/auto/render/qgeometry/tst_qgeometry.cpp
index e790ba9cc..30092b204 100644
--- a/tests/auto/render/qgeometry/tst_qgeometry.cpp
+++ b/tests/auto/render/qgeometry/tst_qgeometry.cpp
@@ -26,15 +26,9 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qgeometry.h>
 #include <Qt3DRender/private/qgeometry_p.h>
@@ -43,17 +37,11 @@ QT_WARNING_DISABLE_DEPRECATED
 
 #include <QSignalSpy>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class FakeGeometry : public Qt3DRender::QGeometry
 {
     Q_OBJECT
-
-public:
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) override
-    {
-        Qt3DRender::QGeometry::sceneChangeEvent(change);
-    }
 };
 
 class tst_QGeometry: public QObject
@@ -62,63 +50,6 @@ class tst_QGeometry: public QObject
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QGeometry *>("geometry");
-        QTest::addColumn<int>("attributeCount");
-
-        Qt3DRender::QGeometry *defaultConstructed = new Qt3DRender::QGeometry();
-        QTest::newRow("defaultConstructed") << defaultConstructed << 0;
-
-        Qt3DRender::QGeometry *geometry1 = new Qt3DRender::QGeometry();
-        Qt3DRender::QAttribute *attribute = new Qt3DRender::QAttribute(nullptr, QStringLiteral("Attr1"), Qt3DRender::QAttribute::Float, 4, 454);
-        geometry1->addAttribute(attribute);
-        geometry1->addAttribute(new Qt3DRender::QAttribute(nullptr, QStringLiteral("Attr2"), Qt3DRender::QAttribute::Float, 4, 555));
-        geometry1->setBoundingVolumePositionAttribute(attribute);
-        QTest::newRow("2 attributes") << geometry1 << 2;
-
-
-        Qt3DRender::QGeometry *geometry2 = new Qt3DRender::QGeometry();
-        attribute = new Qt3DRender::QAttribute(nullptr, QStringLiteral("Attr2"), Qt3DRender::QAttribute::Float, 4, 383);
-        geometry2->addAttribute(new Qt3DRender::QAttribute(nullptr, QStringLiteral("Attr1"), Qt3DRender::QAttribute::Float, 3, 427));
-        geometry2->addAttribute(attribute);
-        geometry2->addAttribute(new Qt3DRender::QAttribute(nullptr, QStringLiteral("Attr3"), Qt3DRender::QAttribute::Float, 2, 327));
-        geometry2->removeAttribute(attribute);
-        QTest::newRow("3 - 1 attributes") << geometry2 << 2;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QGeometry *, geometry);
-        QFETCH(int, attributeCount);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(geometry);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + geometry->childNodes().size());
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QGeometryData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QGeometryData>>(creationChanges.first());
-        const Qt3DRender::QGeometryData &cloneData = creationChangeData->data;
-
-        QCOMPARE(geometry->id(), creationChangeData->subjectId());
-        QCOMPARE(geometry->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(geometry->metaObject(), creationChangeData->metaObject());
-
-        QCOMPARE(attributeCount, geometry->attributes().count());
-        QCOMPARE(attributeCount, cloneData.attributeIds.count());
-        if (geometry->boundingVolumePositionAttribute())
-                QCOMPARE(geometry->boundingVolumePositionAttribute()->id(), cloneData.boundingVolumePositionAttributeId);
-
-        for (int i = 0; i < attributeCount; ++i) {
-            Qt3DRender::QAttribute *originalAttribute = static_cast<Qt3DRender::QAttribute *>(geometry->attributes()[i]);
-            QCOMPARE(originalAttribute->id(), cloneData.attributeIds.at(i));
-        }
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -132,30 +63,25 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometry.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometry.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometry->addAttribute(&attr);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         geometry->removeAttribute(&attr);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometry.data());
-
-        arbiter.events.clear();
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometry.data());
     }
 
     void checkAttributeBookkeeping()
@@ -208,31 +134,26 @@ private Q_SLOTS:
         QCOMPARE(geometry->maxExtent(), QVector3D());
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        valueChange->setPropertyName("extent");
-        valueChange->setValue(QVariant::fromValue(QPair<QVector3D, QVector3D>(QVector3D(10.0f, 10.f, 10.0f),
-                                                                              QVector3D())));
-        geometry->sceneChangeEvent(valueChange);
+        auto dNode = static_cast<Qt3DRender::QGeometryPrivate *>(Qt3DCore::QNodePrivate::get(geometry.data()));
+        const QVector3D minExt(-1.0f, -1.0f, -1.0f);
+        const QVector3D maxExt(1.0f, 1.0f, 1.0f);
+        dNode->setExtent(minExt, maxExt);
 
         // THEN
         QCOMPARE(spyMinExtent.count(), 1);
-        QCOMPARE(spyMaxExtent.count(), 0);
-        QCOMPARE(geometry->minExtent(), QVector3D(10.0f, 10.0f, 10.0f));
+        QCOMPARE(spyMaxExtent.count(), 1);
+        QCOMPARE(geometry->minExtent(), minExt);
+        QCOMPARE(geometry->maxExtent(), maxExt);
 
+        spyMaxExtent.clear();
         spyMinExtent.clear();
 
         // WHEN
-        valueChange->setPropertyName("extent");
-        valueChange->setValue(QVariant::fromValue(QPair<QVector3D, QVector3D>(QVector3D(10.0f, 10.f, 10.0f),
-                                                                              QVector3D(11.0f, 11.f, 11.0f))));
-        geometry->sceneChangeEvent(valueChange);
+        dNode->setExtent(minExt, maxExt);
 
         // THEN
         QCOMPARE(spyMinExtent.count(), 0);
-        QCOMPARE(spyMaxExtent.count(), 1);
-        QCOMPARE(geometry->maxExtent(), QVector3D(11.0f, 11.0f, 11.0f));
-
-        spyMaxExtent.clear();
+        QCOMPARE(spyMaxExtent.count(), 0);
     }
 };
 
diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
index 8cfbc0d23..1c2d30b49 100644
--- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
+++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
@@ -33,7 +33,6 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qgeometryrenderer.h>
 #include <Qt3DRender/qgeometryfactory.h>
@@ -42,7 +41,7 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DRender/qbuffer.h>
 #include <Qt3DRender/private/qgeometryrenderer_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class TestFactory : public Qt3DRender::QGeometryFactory
 {
@@ -76,80 +75,6 @@ class tst_QGeometryRenderer: public QObject
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QGeometryRenderer *>("geometryRenderer");
-
-        Qt3DRender::QGeometryRenderer *defaultConstructed = new Qt3DRender::QGeometryRenderer();
-        QTest::newRow("defaultConstructed") << defaultConstructed ;
-
-        Qt3DRender::QGeometryRenderer *geometry1 = new Qt3DRender::QGeometryRenderer();
-        geometry1->setGeometry(new Qt3DRender::QGeometry());
-        geometry1->setInstanceCount(1);
-        geometry1->setIndexOffset(0);
-        geometry1->setFirstInstance(55);
-        geometry1->setIndexBufferByteOffset(48);
-        geometry1->setRestartIndexValue(-1);
-        geometry1->setPrimitiveRestartEnabled(false);
-        geometry1->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles);
-        geometry1->setVertexCount(15);
-        geometry1->setVerticesPerPatch(2);
-        geometry1->setGeometryFactory(Qt3DRender::QGeometryFactoryPtr(new TestFactory(383)));
-        QTest::newRow("triangle") << geometry1;
-
-        Qt3DRender::QGeometryRenderer *geometry2 = new Qt3DRender::QGeometryRenderer();
-        geometry2->setGeometry(new Qt3DRender::QGeometry());
-        geometry2->setInstanceCount(200);
-        geometry2->setIndexOffset(58);
-        geometry2->setFirstInstance(10);
-        geometry2->setIndexBufferByteOffset(96);
-        geometry2->setRestartIndexValue(65535);
-        geometry2->setVertexCount(2056);
-        geometry2->setPrimitiveRestartEnabled(true);
-        geometry2->setVerticesPerPatch(3);
-        geometry2->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
-        geometry2->setGeometryFactory(Qt3DRender::QGeometryFactoryPtr(new TestFactory(305)));
-        QTest::newRow("lines with restart") << geometry2;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QGeometryRenderer *, geometryRenderer);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(geometryRenderer);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (geometryRenderer->geometry() ? 1 : 0));
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QGeometryRendererData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QGeometryRendererData>>(creationChanges.first());
-        const Qt3DRender::QGeometryRendererData &cloneData = creationChangeData->data;
-
-        QCOMPARE(geometryRenderer->id(), creationChangeData->subjectId());
-        QCOMPARE(geometryRenderer->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(geometryRenderer->metaObject(), creationChangeData->metaObject());
-
-        QCOMPARE(cloneData.instanceCount, geometryRenderer->instanceCount());
-        QCOMPARE(cloneData.vertexCount, geometryRenderer->vertexCount());
-        QCOMPARE(cloneData.indexOffset, geometryRenderer->indexOffset());
-        QCOMPARE(cloneData.firstInstance, geometryRenderer->firstInstance());
-        QCOMPARE(cloneData.indexBufferByteOffset, geometryRenderer->indexBufferByteOffset());
-        QCOMPARE(cloneData.restartIndexValue, geometryRenderer->restartIndexValue());
-        QCOMPARE(cloneData.primitiveRestart, geometryRenderer->primitiveRestartEnabled());
-        QCOMPARE(cloneData.primitiveType, geometryRenderer->primitiveType());
-        QCOMPARE(cloneData.verticesPerPatch, geometryRenderer->verticesPerPatch());
-
-        if (geometryRenderer->geometry() != nullptr)
-            QCOMPARE(cloneData.geometryId, geometryRenderer->geometry()->id());
-
-        QCOMPARE(cloneData.geometryFactory, geometryRenderer->geometryFactory());
-        if (geometryRenderer->geometryFactory())
-            QVERIFY(*cloneData.geometryFactory == *geometryRenderer->geometryFactory());
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -162,99 +87,90 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setVertexCount(1340);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setIndexOffset(883);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setFirstInstance(1200);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setIndexBufferByteOffset(91);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setRestartIndexValue(65535);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setVerticesPerPatch(2);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setPrimitiveRestartEnabled(true);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QGeometryFactoryPtr factory(new TestFactory(555));
@@ -262,11 +178,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QGeometry geom;
@@ -274,11 +189,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QGeometry geom2;
@@ -286,11 +200,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), geometryRenderer.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), geometryRenderer.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkGeometryBookkeeping()
diff --git a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
index 648a1d104..da31944f7 100644
--- a/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
+++ b/tests/auto/render/qlayerfilter/tst_qlayerfilter.cpp
@@ -29,13 +29,12 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qlayer.h>
 #include <Qt3DRender/qlayerfilter.h>
 #include <Qt3DRender/private/qlayerfilter_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QLayerFilter: public QObject
 {
@@ -49,60 +48,6 @@ public:
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QLayerFilter *>("layerFilter");
-        QTest::addColumn<QVector<Qt3DRender::QLayer*>>("layers");
-
-
-        Qt3DRender::QLayerFilter *defaultConstructed = new Qt3DRender::QLayerFilter();
-        QTest::newRow("defaultConstructed") << defaultConstructed << QVector<Qt3DRender::QLayer*>();
-
-        Qt3DRender::QLayerFilter *singleLayer = new Qt3DRender::QLayerFilter();
-        auto layer = QVector<Qt3DRender::QLayer*>() << new Qt3DRender::QLayer();
-        QCoreApplication::processEvents();
-        singleLayer->addLayer(layer.first());
-        QTest::newRow("single layer") << singleLayer << layer;
-
-        Qt3DRender::QLayerFilter *multiLayers = new Qt3DRender::QLayerFilter();
-        auto layers = QVector<Qt3DRender::QLayer*>() << new Qt3DRender::QLayer()
-                                                     << new Qt3DRender::QLayer()
-                                                     << new Qt3DRender::QLayer();
-        QCoreApplication::processEvents();
-        for (Qt3DRender::QLayer *layer : qAsConst(layers))
-            multiLayers->addLayer(layer);
-        QTest::newRow("multi layers") << multiLayers << layers;
-     }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QLayerFilter *, layerFilter);
-        QFETCH(QVector<Qt3DRender::QLayer*>, layers);
-
-        // THEN
-        QCOMPARE(layerFilter->layers(), layers);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(layerFilter);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), layers.size() + 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QLayerFilterData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QLayerFilterData>>(creationChanges.first());
-        const Qt3DRender::QLayerFilterData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(layerFilter->id(), creationChangeData->subjectId());
-        QCOMPARE(layerFilter->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(layerFilter->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(Qt3DCore::qIdsForNodes(layerFilter->layers()), cloneData.layerIds);
-
-        delete layerFilter;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -117,11 +62,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(layerFilter.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         layer = new Qt3DRender::QLayer(layerFilter.data());
@@ -130,11 +74,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(layerFilter.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         layer = layerFilter->layers().at(0);
@@ -142,11 +85,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(layerFilter.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(layerFilter.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkLayerBookkeeping()
diff --git a/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp b/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp
index 7d4e5d45d..0c68cf42c 100644
--- a/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp
+++ b/tests/auto/render/qlevelofdetail/tst_qlevelofdetail.cpp
@@ -29,12 +29,11 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qlevelofdetail.h>
 #include <Qt3DRender/private/qlevelofdetail_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QLevelOfDetail: public QObject
 {
@@ -42,44 +41,6 @@ class tst_QLevelOfDetail: public QObject
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QLevelOfDetail *>("lod");
-
-        Qt3DRender::QLevelOfDetail *defaultConstructed = new Qt3DRender::QLevelOfDetail();
-        QTest::newRow("defaultConstructed") << defaultConstructed;
-
-        Qt3DRender::QLevelOfDetail *lodDst = new Qt3DRender::QLevelOfDetail();
-        QTest::newRow("distLod") << lodDst;
-
-        Qt3DRender::QLevelOfDetail *lodPx = new Qt3DRender::QLevelOfDetail();
-        QTest::newRow("pxLod") << lodPx;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QLevelOfDetail *, lod);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(lod);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QLevelOfDetailData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QLevelOfDetailData>>(creationChanges.first());
-        const Qt3DRender::QLevelOfDetailData &cloneData = creationChangeData->data;
-
-        QCOMPARE(lod->id(), creationChangeData->subjectId());
-        QCOMPARE(lod->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(lod->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(lod->currentIndex(), cloneData.currentIndex);
-        QCOMPARE(lod->thresholdType(), cloneData.thresholdType);
-        QCOMPARE(lod->thresholds(), cloneData.thresholds);
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -93,11 +54,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), lod.data());
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), lod.data());
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -107,11 +67,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), lod.data());
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), lod.data());
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 };
diff --git a/tests/auto/render/qmaterial/tst_qmaterial.cpp b/tests/auto/render/qmaterial/tst_qmaterial.cpp
index 994b11d43..50e2d9989 100644
--- a/tests/auto/render/qmaterial/tst_qmaterial.cpp
+++ b/tests/auto/render/qmaterial/tst_qmaterial.cpp
@@ -30,7 +30,6 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DRender/private/qrenderstate_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/QEffect>
 #include <Qt3DRender/QMaterial>
@@ -47,7 +46,7 @@
 
 #include <Qt3DRender/private/qmaterial_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class TestMaterial : public Qt3DRender::QMaterial
 {
@@ -185,61 +184,6 @@ private:
 
 private Q_SLOTS:
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QMaterial *>("material");
-
-        Qt3DRender::QMaterial *material = new Qt3DRender::QMaterial();
-        QTest::newRow("empty material") << material;
-        material = new TestMaterial();
-        QTest::newRow("test material") << material;
-        material = new Qt3DExtras::QPhongMaterial();
-        QTest::newRow("QPhongMaterial") << material;
-        material = new Qt3DExtras::QDiffuseMapMaterial();
-        QTest::newRow("QDiffuseMapMaterial") << material;
-        material = new Qt3DExtras::QDiffuseSpecularMapMaterial();
-        QTest::newRow("QDiffuseMapSpecularMaterial") << material;
-        material = new Qt3DExtras::QPerVertexColorMaterial();
-        QTest::newRow("QPerVertexColorMaterial") << material;
-        material = new Qt3DExtras::QNormalDiffuseMapMaterial();
-        QTest::newRow("QNormalDiffuseMapMaterial") << material;
-        material = new Qt3DExtras::QNormalDiffuseMapAlphaMaterial();
-        QTest::newRow("QNormalDiffuseMapAlphaMaterial") << material;
-        material = new Qt3DExtras::QNormalDiffuseSpecularMapMaterial();
-        QTest::newRow("QNormalDiffuseSpecularMapMaterial") << material;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QMaterial *, material);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(material);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QVERIFY(creationChanges.size() >= 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QMaterialData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QMaterialData>>(creationChanges.first());
-        const Qt3DRender::QMaterialData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(material->id(), creationChangeData->subjectId());
-        QCOMPARE(material->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(material->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(material->effect() ? material->effect()->id() : Qt3DCore::QNodeId(), cloneData.effectId);
-        QCOMPARE(material->parameters().size(), cloneData.parameterIds.size());
-
-        for (int i = 0, m = material->parameters().size(); i < m; ++i)
-            QCOMPARE(material->parameters().at(i)->id(), cloneData.parameterIds.at(i));
-
-        // TO DO: Add unit tests for parameter and effect that do check this
-        //        compareParameters(material->parameters(), clone->parameters());
-        //        compareEffects(material->effect(), clone->effect());
-    }
-
     void checkEffectUpdate()
     {
         // GIVEN
@@ -252,10 +196,10 @@ private Q_SLOTS:
         material->setEffect(&effect);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), material.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), material.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // GIVEN
         TestArbiter arbiter2;
@@ -266,10 +210,10 @@ private Q_SLOTS:
         material2->setEffect(&effect);
 
         // THEN
-        QCOMPARE(arbiter2.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter2.dirtyNodes.front(), material2.data());
+        QCOMPARE(arbiter2.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter2.dirtyNodes().front(), material2.data());
 
-        arbiter2.dirtyNodes.clear();
+        arbiter2.clear();
     }
 
     void checkDynamicParametersAddedUpdates()
@@ -281,7 +225,7 @@ private Q_SLOTS:
 
         QCoreApplication::processEvents();
         // Clear events trigger by child generation of TestMnterial
-        arbiter.events.clear();
+        arbiter.clear();
 
         // WHEN (add parameter to material)
         Qt3DRender::QParameter *param = new Qt3DRender::QParameter("testParamMaterial", QVariant::fromValue(383.0f));
@@ -292,8 +236,7 @@ private Q_SLOTS:
         QCOMPARE(param->parent(), material);
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
         QVERIFY(material->parameters().contains(param));
 
         // WHEN (add parameter to effect)
@@ -302,8 +245,7 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 2);
+        QCOMPARE(arbiter.dirtyNodes().size(), 2);
         QVERIFY(material->effect()->parameters().contains(param));
 
         // WHEN (add parameter to technique)
@@ -312,8 +254,7 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 3);
+        QCOMPARE(arbiter.dirtyNodes().size(), 3);
         QVERIFY(material->m_technique->parameters().contains(param));
 
 
@@ -323,8 +264,7 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 4);
+        QCOMPARE(arbiter.dirtyNodes().size(), 4);
         QVERIFY(material->m_renderPass->parameters().contains(param));
     }
 
@@ -340,59 +280,59 @@ private Q_SLOTS:
         material->m_shaderProgram->setVertexShaderCode(vertexCode);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), material->m_shaderProgram);
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         const QByteArray fragmentCode = QByteArrayLiteral("new fragment shader code");
         material->m_shaderProgram->setFragmentShaderCode(fragmentCode);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), material->m_shaderProgram);
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
         // WHEN
         const QByteArray geometryCode = QByteArrayLiteral("new geometry shader code");
         material->m_shaderProgram->setGeometryShaderCode(geometryCode);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), material->m_shaderProgram);
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         const QByteArray computeCode = QByteArrayLiteral("new compute shader code");
         material->m_shaderProgram->setComputeShaderCode(computeCode);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), material->m_shaderProgram);
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         const QByteArray tesselControlCode = QByteArrayLiteral("new tessellation control shader code");
         material->m_shaderProgram->setTessellationControlShaderCode(tesselControlCode);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), material->m_shaderProgram);
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         const QByteArray tesselEvalCode = QByteArrayLiteral("new tessellation eval shader code");
         material->m_shaderProgram->setTessellationEvaluationShaderCode(tesselEvalCode);
 
         // THEN
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), material->m_shaderProgram);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), material->m_shaderProgram);
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkEffectBookkeeping()
diff --git a/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp b/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp
index 41fdd8428..ae1d3360c 100644
--- a/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp
+++ b/tests/auto/render/qmemorybarrier/tst_qmemorybarrier.cpp
@@ -32,9 +32,7 @@
 #include <Qt3DRender/private/qmemorybarrier_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QMemoryBarrier : public QObject
 {
@@ -82,58 +80,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QMemoryBarrier memoryBarrier;
-
-        memoryBarrier.setWaitOperations(Qt3DRender::QMemoryBarrier::Command);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&memoryBarrier);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QMemoryBarrierData>>(creationChanges.first());
-            const Qt3DRender::QMemoryBarrierData cloneData = creationChangeData->data;
-
-            QCOMPARE(memoryBarrier.waitOperations(), cloneData.waitOperations);
-            QCOMPARE(memoryBarrier.id(), creationChangeData->subjectId());
-            QCOMPARE(memoryBarrier.isEnabled(), true);
-            QCOMPARE(memoryBarrier.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(memoryBarrier.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        memoryBarrier.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&memoryBarrier);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QMemoryBarrierData>>(creationChanges.first());
-            const Qt3DRender::QMemoryBarrierData cloneData = creationChangeData->data;
-
-            QCOMPARE(memoryBarrier.waitOperations(), cloneData.waitOperations);
-            QCOMPARE(memoryBarrier.id(), creationChangeData->subjectId());
-            QCOMPARE(memoryBarrier.isEnabled(), false);
-            QCOMPARE(memoryBarrier.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(memoryBarrier.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkTypesUpdate()
     {
         // GIVEN
@@ -147,11 +93,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &memoryBarrier);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &memoryBarrier);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -160,8 +105,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qmesh/tst_qmesh.cpp b/tests/auto/render/qmesh/tst_qmesh.cpp
index d77005dfa..cc66316ae 100644
--- a/tests/auto/render/qmesh/tst_qmesh.cpp
+++ b/tests/auto/render/qmesh/tst_qmesh.cpp
@@ -35,11 +35,8 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DRender/private/qmesh_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MyQMesh : public Qt3DRender::QMesh
 {
@@ -48,11 +45,6 @@ public:
     explicit MyQMesh(Qt3DCore::QNode *parent = nullptr)
         : Qt3DRender::QMesh(parent)
     {}
-
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) final
-    {
-        Qt3DRender::QMesh::sceneChangeEvent(change);
-    }
 };
 
 class tst_QMesh : public QObject
@@ -117,58 +109,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QMesh mesh;
-
-        mesh.setSource(QUrl(QStringLiteral("http://someRemoteURL.com")));
-        mesh.setMeshName(QStringLiteral("RearPropeller"));
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mesh);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QGeometryRendererData>>(creationChanges.first());
-            const Qt3DRender::QGeometryRendererData cloneData = creationChangeData->data;
-
-            // Geometry factory shouldn't be null
-            QVERIFY(cloneData.geometryFactory != nullptr);
-            QCOMPARE(mesh.id(), creationChangeData->subjectId());
-            QCOMPARE(mesh.isEnabled(), true);
-            QCOMPARE(mesh.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mesh.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        mesh.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&mesh);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QGeometryRendererData>>(creationChanges.first());
-
-            QCOMPARE(mesh.id(), creationChangeData->subjectId());
-            QCOMPARE(mesh.isEnabled(), false);
-            QCOMPARE(mesh.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(mesh.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkSourceUpdate()
     {
         // GIVEN
@@ -181,7 +121,7 @@ private Q_SLOTS:
         Qt3DCore::QNodePrivate *meshd = Qt3DCore::QNodePrivate::get(&mesh);
         meshd->setScene(scene);
         QCoreApplication::processEvents();
-        arbiter.events.clear();
+        arbiter.clear();
 
         {
             // WHEN
@@ -189,10 +129,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mesh);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mesh);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -201,7 +141,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -218,7 +158,7 @@ private Q_SLOTS:
         Qt3DCore::QNodePrivate *meshd = Qt3DCore::QNodePrivate::get(&mesh);
         meshd->setScene(scene);
         QCoreApplication::processEvents();
-        arbiter.events.clear();
+        arbiter.clear();
 
         {
             // WHEN
@@ -226,10 +166,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &mesh);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &mesh);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -238,7 +178,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
index 5977829a6..81b0110b1 100644
--- a/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
+++ b/tests/auto/render/qobjectpicker/tst_qobjectpicker.cpp
@@ -33,9 +33,7 @@
 #include <Qt3DRender/QObjectPicker>
 #include <Qt3DRender/private/qobjectpicker_p.h>
 #include <Qt3DRender/QPickEvent>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MyObjectPicker : public Qt3DRender::QObjectPicker
 {
@@ -45,11 +43,6 @@ public:
         : Qt3DRender::QObjectPicker(parent)
     {}
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) final
-    {
-        Qt3DRender::QObjectPicker::sceneChangeEvent(change);
-    }
-
 private:
     friend class tst_ObjectPicker;
 
@@ -84,64 +77,6 @@ private Q_SLOTS:
         QCOMPARE(picker.isHoverEnabled(), false);
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QObjectPicker picker;
-
-        picker.setPriority(1584);
-        picker.setDragEnabled(true);
-        picker.setHoverEnabled(true);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&picker);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QObjectPickerData>>(creationChanges.first());
-            const Qt3DRender::QObjectPickerData cloneData = creationChangeData->data;
-
-            QCOMPARE(cloneData.priority, 1584);
-            QCOMPARE(cloneData.hoverEnabled, true);
-            QCOMPARE(cloneData.dragEnabled, true);
-            QCOMPARE(picker.id(), creationChangeData->subjectId());
-            QCOMPARE(picker.isEnabled(), true);
-            QCOMPARE(picker.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(picker.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        picker.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&picker);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QObjectPickerData>>(creationChanges.first());
-            const Qt3DRender::QObjectPickerData cloneData = creationChangeData->data;
-
-            QCOMPARE(cloneData.priority, 1584);
-            QCOMPARE(cloneData.hoverEnabled, true);
-            QCOMPARE(cloneData.dragEnabled, true);
-            QCOMPARE(picker.id(), creationChangeData->subjectId());
-            QCOMPARE(picker.isEnabled(), false);
-            QCOMPARE(picker.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(picker.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkPropertyUpdate()
     {
         // GIVEN
@@ -156,11 +91,10 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 1);
-                QCOMPARE(arbiter.dirtyNodes.front(), &picker);
+                QCOMPARE(arbiter.dirtyNodes().size(), 1);
+                QCOMPARE(arbiter.dirtyNodes().front(), &picker);
 
-                arbiter.dirtyNodes.clear();
+                arbiter.clear();
             }
 
             {
@@ -169,8 +103,7 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes().size(), 0);
             }
         }
         {
@@ -180,11 +113,10 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 1);
-                QCOMPARE(arbiter.dirtyNodes.front(), &picker);
+                QCOMPARE(arbiter.dirtyNodes().size(), 1);
+                QCOMPARE(arbiter.dirtyNodes().front(), &picker);
 
-                arbiter.dirtyNodes.clear();
+                arbiter.clear();
             }
 
             {
@@ -193,8 +125,7 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes().size(), 0);
             }
         }
         {
@@ -204,11 +135,10 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 1);
-                QCOMPARE(arbiter.dirtyNodes.front(), &picker);
+                QCOMPARE(arbiter.dirtyNodes().size(), 1);
+                QCOMPARE(arbiter.dirtyNodes().front(), &picker);
 
-                arbiter.dirtyNodes.clear();
+                arbiter.clear();
             }
 
             {
@@ -217,8 +147,7 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes().size(), 0);
             }
         }
     }
@@ -248,11 +177,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), objectPicker.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), objectPicker.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 };
 
diff --git a/tests/auto/render/qparameter/tst_qparameter.cpp b/tests/auto/render/qparameter/tst_qparameter.cpp
index 3df09cff4..b4c307dc6 100644
--- a/tests/auto/render/qparameter/tst_qparameter.cpp
+++ b/tests/auto/render/qparameter/tst_qparameter.cpp
@@ -31,10 +31,8 @@
 #include <Qt3DRender/private/qparameter_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
 #include <Qt3DCore/qentity.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QParameter : public QObject
 {
@@ -97,61 +95,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QParameter parameter;
-
-        parameter.setName(QStringLiteral("TwinCam"));
-        parameter.setValue(QVariant(427));
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&parameter);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QParameterData>>(creationChanges.first());
-            const Qt3DRender::QParameterData cloneData = creationChangeData->data;
-
-            QCOMPARE(parameter.name(), cloneData.name);
-            QCOMPARE(parameter.value(), cloneData.backendValue);
-            QCOMPARE(parameter.id(), creationChangeData->subjectId());
-            QCOMPARE(parameter.isEnabled(), true);
-            QCOMPARE(parameter.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(parameter.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        parameter.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&parameter);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QParameterData>>(creationChanges.first());
-            const Qt3DRender::QParameterData cloneData = creationChangeData->data;
-
-            QCOMPARE(parameter.name(), cloneData.name);
-            QCOMPARE(parameter.value(), cloneData.backendValue);
-            QCOMPARE(parameter.id(), creationChangeData->subjectId());
-            QCOMPARE(parameter.isEnabled(), false);
-            QCOMPARE(parameter.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(parameter.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkNameUpdate()
     {
         // GIVEN
@@ -165,11 +108,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &parameter);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &parameter);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -178,8 +120,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -197,11 +138,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &parameter);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &parameter);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -210,8 +150,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         // WHEN -> QNode -> QNodeId
@@ -224,11 +163,10 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 1);
-                QCOMPARE(arbiter.dirtyNodes.front(), &parameter);
+                QCOMPARE(arbiter.dirtyNodes().size(), 1);
+                QCOMPARE(arbiter.dirtyNodes().front(), &parameter);
 
-                arbiter.dirtyNodes.clear();
+                arbiter.clear();
             }
 
             {
@@ -237,8 +175,7 @@ private Q_SLOTS:
                 QCoreApplication::processEvents();
 
                 // THEN
-                QCOMPARE(arbiter.events.size(), 0);
-                QCOMPARE(arbiter.dirtyNodes.size(), 0);
+                QCOMPARE(arbiter.dirtyNodes().size(), 0);
             }
 
         }
diff --git a/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp b/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp
index 10a532454..3336d757e 100644
--- a/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp
+++ b/tests/auto/render/qproximityfilter/tst_qproximityfilter.cpp
@@ -31,10 +31,8 @@
 #include <Qt3DRender/private/qproximityfilter_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
 #include <Qt3DCore/qentity.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QProximityFilter : public QObject
 {
@@ -105,62 +103,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QProximityFilter proximityFilter;
-        Qt3DCore::QEntity entity;
-
-        proximityFilter.setEntity(&entity);
-        proximityFilter.setDistanceThreshold(1584.0f);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&proximityFilter);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // Entity creation change is the second change
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QProximityFilterData>>(creationChanges.first());
-            const Qt3DRender::QProximityFilterData cloneData = creationChangeData->data;
-
-            QCOMPARE(proximityFilter.entity()->id(), cloneData.entityId);
-            QCOMPARE(proximityFilter.distanceThreshold(), cloneData.distanceThreshold);
-            QCOMPARE(proximityFilter.id(), creationChangeData->subjectId());
-            QCOMPARE(proximityFilter.isEnabled(), true);
-            QCOMPARE(proximityFilter.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(proximityFilter.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        proximityFilter.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&proximityFilter);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // Entity creation change is the second change
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QProximityFilterData>>(creationChanges.first());
-            const Qt3DRender::QProximityFilterData cloneData = creationChangeData->data;
-
-            QCOMPARE(proximityFilter.entity()->id(), cloneData.entityId);
-            QCOMPARE(proximityFilter.distanceThreshold(), cloneData.distanceThreshold);
-            QCOMPARE(proximityFilter.id(), creationChangeData->subjectId());
-            QCOMPARE(proximityFilter.isEnabled(), false);
-            QCOMPARE(proximityFilter.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(proximityFilter.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkEntityUpdate()
     {
         // GIVEN
@@ -175,11 +117,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &proximityFilter);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &proximityFilter);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -188,8 +129,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -207,11 +147,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &proximityFilter);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &proximityFilter);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -220,8 +159,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qraycaster/tst_qraycaster.cpp b/tests/auto/render/qraycaster/tst_qraycaster.cpp
index 8ac084545..96f6d92eb 100644
--- a/tests/auto/render/qraycaster/tst_qraycaster.cpp
+++ b/tests/auto/render/qraycaster/tst_qraycaster.cpp
@@ -30,13 +30,11 @@
 #include <QtTest/QSignalSpy>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
 #include <Qt3DRender/QRayCaster>
+#include <Qt3DRender/private/qabstractraycaster_p.h>
 #include <Qt3DRender/QLayer>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MyRayCaster : public Qt3DRender::QRayCaster
 {
@@ -48,11 +46,6 @@ public:
         qRegisterMetaType<Qt3DRender::QAbstractRayCaster::Hits>("Hits");
     }
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) final
-    {
-        Qt3DRender::QRayCaster::sceneChangeEvent(change);
-    }
-
 private:
     friend class tst_RayCaster;
 };
@@ -112,11 +105,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), rayCaster.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), rayCaster.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         auto layer = new Qt3DRender::QLayer(rayCaster.data());
@@ -125,12 +117,9 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), rayCaster.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
-        arbiter.dirtyNodes.clear();
-        arbiter.events.clear();
+        arbiter.clear();
 
         // WHEN
         layer = new Qt3DRender::QLayer(rayCaster.data());
@@ -139,12 +128,9 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), rayCaster.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
-        arbiter.dirtyNodes.clear();
-        arbiter.events.clear();
+        arbiter.clear();
 
         // WHEN
         layer = rayCaster->layers().at(0);
@@ -152,12 +138,9 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), rayCaster.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
-        arbiter.dirtyNodes.clear();
-        arbiter.events.clear();
+        arbiter.clear();
     }
 
     void checkLayerBookkeeping()
@@ -194,14 +177,23 @@ private Q_SLOTS:
         }
     }
 
-    void checkBackendUpdates_data()
+
+    void checkBackendUpdates()
     {
-        QTest::addColumn<QByteArray>("signalPrototype");
-        QTest::addColumn<QByteArray>("propertyName");
+        // GIVEN
+        QScopedPointer<MyRayCaster> rayCaster(new MyRayCaster());
+        QSignalSpy spy(rayCaster.data(), SIGNAL(hitsChanged(const Hits &)));
+        Qt3DRender::QRayCaster::Hits hits;
 
-        QTest::newRow("hits")
-                << QByteArray(SIGNAL(hitsChanged(const Hits &)))
-                << QByteArrayLiteral("hits");
+        QVERIFY(spy.isValid());
+
+        // WHEN
+        Qt3DRender::QAbstractRayCasterPrivate *d = Qt3DRender::QAbstractRayCasterPrivate::get(rayCaster.data());
+        d->dispatchHits(hits);
+
+        // THEN
+        // Check that the QRayCaster triggers the expected signal
+        QCOMPARE(spy.count(), 1);
     }
 };
 
diff --git a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
index 35c645d41..2b4fcec6b 100644
--- a/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
+++ b/tests/auto/render/qrendercapture/tst_qrendercapture.cpp
@@ -26,13 +26,8 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
 #include <QtTest/QSignalSpy>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DRender/QRenderCapture>
@@ -40,7 +35,7 @@ QT_WARNING_DISABLE_DEPRECATED
 
 #include <QPointer>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MyRenderCapture : public Qt3DRender::QRenderCapture
 {
@@ -50,11 +45,6 @@ public:
         : Qt3DRender::QRenderCapture(parent)
     {}
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) final
-    {
-        Qt3DRender::QRenderCapture::sceneChangeEvent(change);
-    }
-
 private:
     friend class tst_QRenderCapture;
 };
@@ -76,58 +66,10 @@ private Q_SLOTS:
         QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture(QRect(10, 15, 20, 50)));
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), renderCapture.data());
-
-        arbiter.dirtyNodes.clear();
-    }
-
-    void checkRenderCaptureReply()
-    {
-        // GIVEN
-        QScopedPointer<MyRenderCapture> renderCapture(new MyRenderCapture());
-        QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture());
-        QImage img = QImage(20, 20, QImage::Format_ARGB32);
-
-        // WHEN
-        Qt3DRender::RenderCaptureDataPtr data = Qt3DRender::RenderCaptureDataPtr::create();
-        data.data()->captureId = 2;
-        data.data()->image = img;
-
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(renderCapture->id());
-        e->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
-        e->setPropertyName("renderCaptureData");
-        e->setValue(QVariant::fromValue(data));
-
-        renderCapture->sceneChangeEvent(e);
-
-        // THEN
-        QCOMPARE(reply->isComplete(), true);
-        QCOMPARE(reply->image().width(), 20);
-        QCOMPARE(reply->image().height(), 20);
-        QCOMPARE(reply->image().format(), QImage::Format_ARGB32);
-    }
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), renderCapture.data());
 
-    void checkRenderCaptureDestroy()
-    {
-        // GIVEN
-        QScopedPointer<MyRenderCapture> renderCapture(new MyRenderCapture());
-        QScopedPointer<Qt3DRender::QRenderCaptureReply> reply(renderCapture->requestCapture());
-        QImage img = QImage(20, 20, QImage::Format_ARGB32);
-        Qt3DRender::RenderCaptureDataPtr data = Qt3DRender::RenderCaptureDataPtr::create();
-        data.data()->captureId = 2;
-        data.data()->image = img;
-        auto e = Qt3DCore::QPropertyUpdatedChangePtr::create(renderCapture->id());
-        e->setDeliveryFlags(Qt3DCore::QSceneChange::DeliverToAll);
-        e->setPropertyName("renderCaptureData");
-        e->setValue(QVariant::fromValue(data));
-
-        // WHEN
-        reply.reset();
-
-        // THEN
-        renderCapture->sceneChangeEvent(e); // Should not reset
+        arbiter.clear();
     }
 
     void crashOnRenderCaptureDeletion()
diff --git a/tests/auto/render/qrenderpass/tst_qrenderpass.cpp b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
index 81f949064..479fffa29 100644
--- a/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
+++ b/tests/auto/render/qrenderpass/tst_qrenderpass.cpp
@@ -36,11 +36,7 @@
 #include <Qt3DRender/private/qrenderpass_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/qpropertynodeaddedchange.h>
-#include <Qt3DCore/qpropertynoderemovedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QRenderPass : public QObject
 {
@@ -151,77 +147,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QRenderPass renderPass;
-
-        Qt3DRender::QShaderProgram shader;
-        renderPass.setShaderProgram(&shader);
-        Qt3DRender::QFilterKey filterKey;
-        renderPass.addFilterKey(&filterKey);
-        Qt3DRender::QDepthTest renderState;
-        renderPass.addRenderState(&renderState);
-        Qt3DRender::QParameter parameter;
-        renderPass.addParameter(&parameter);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderPass);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 5); // RenderPass + Shader + FilterKey + Parameter + State
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderPassData>>(creationChanges.first());
-            const Qt3DRender::QRenderPassData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderPass.shaderProgram()->id(), cloneData.shaderId);
-            QCOMPARE(cloneData.filterKeyIds.size(), 1);
-            QCOMPARE(filterKey.id(), cloneData.filterKeyIds.first());
-            QCOMPARE(cloneData.renderStateIds.size(), 1);
-            QCOMPARE(renderState.id(), cloneData.renderStateIds.first());
-            QCOMPARE(cloneData.parameterIds.size(), 1);
-            QCOMPARE(parameter.id(), cloneData.parameterIds.first());
-            QCOMPARE(renderPass.id(), creationChangeData->subjectId());
-            QCOMPARE(renderPass.isEnabled(), true);
-            QCOMPARE(renderPass.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderPass.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        renderPass.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderPass);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 5); // RenderPass + Shader + FilterKey + Parameter + State
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderPassData>>(creationChanges.first());
-            const Qt3DRender::QRenderPassData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderPass.shaderProgram()->id(), cloneData.shaderId);
-            QCOMPARE(cloneData.filterKeyIds.size(), 1);
-            QCOMPARE(filterKey.id(), cloneData.filterKeyIds.first());
-            QCOMPARE(cloneData.renderStateIds.size(), 1);
-            QCOMPARE(renderState.id(), cloneData.renderStateIds.first());
-            QCOMPARE(cloneData.parameterIds.size(), 1);
-            QCOMPARE(parameter.id(), cloneData.parameterIds.first());
-            QCOMPARE(renderPass.id(), creationChangeData->subjectId());
-            QCOMPARE(renderPass.isEnabled(), false);
-            QCOMPARE(renderPass.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderPass.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkShaderProgramBookkeeping()
     {
         // GIVEN
@@ -304,11 +229,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderPass);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -317,8 +241,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -337,11 +260,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderPass);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
         {
@@ -350,11 +272,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderPass);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
     }
@@ -373,11 +294,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderPass);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
         {
@@ -386,11 +306,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderPass);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
     }
@@ -409,11 +328,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderPass);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
         {
@@ -422,11 +340,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderPass);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderPass);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
     }
diff --git a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
index d12f04e33..6441119f2 100644
--- a/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
+++ b/tests/auto/render/qrenderpassfilter/tst_qrenderpassfilter.cpp
@@ -30,14 +30,13 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qrenderpassfilter.h>
 #include <Qt3DRender/private/qrenderpassfilter_p.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qfilterkey.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QRenderPassFilter: public QObject
 {
@@ -53,90 +52,6 @@ private Q_SLOTS:
         QCOMPARE(defaultRenderPassFilter->parameters().count(), 0);
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QRenderPassFilter *>("renderPassFilter");
-        QTest::addColumn<QVector<Qt3DRender::QParameter *> >("parameters");
-        QTest::addColumn<QVector<Qt3DRender::QFilterKey *> >("filterKeys");
-
-        Qt3DRender::QRenderPassFilter *defaultConstructed = new Qt3DRender::QRenderPassFilter();
-        QTest::newRow("defaultConstructed") << defaultConstructed << QVector<Qt3DRender::QParameter *>() << QVector<Qt3DRender::QFilterKey *>();
-
-        Qt3DRender::QRenderPassFilter *renderPassFilterWithParams = new Qt3DRender::QRenderPassFilter();
-        Qt3DRender::QParameter *parameter1 = new Qt3DRender::QParameter(QStringLiteral("displacement"), 454.0f);
-        Qt3DRender::QParameter *parameter2 = new Qt3DRender::QParameter(QStringLiteral("torque"), 650);
-        QVector<Qt3DRender::QParameter *> params1 = QVector<Qt3DRender::QParameter *>() << parameter1 << parameter2;
-        renderPassFilterWithParams->addParameter(parameter1);
-        renderPassFilterWithParams->addParameter(parameter2);
-        QTest::newRow("renderPassFilterWithParams") << renderPassFilterWithParams << params1 << QVector<Qt3DRender::QFilterKey *>();
-
-        Qt3DRender::QRenderPassFilter *renderPassFilterWithAnnotations = new Qt3DRender::QRenderPassFilter();
-        Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
-        Qt3DRender::QFilterKey *filterKey2 = new Qt3DRender::QFilterKey();
-        filterKey1->setName(QStringLiteral("hasSuperCharger"));
-        filterKey1->setValue(true);
-        filterKey1->setName(QStringLiteral("hasNitroKit"));
-        filterKey1->setValue(false);
-        QVector<Qt3DRender::QFilterKey *> filterKeys1 = QVector<Qt3DRender::QFilterKey *>() << filterKey1 << filterKey2;
-        renderPassFilterWithAnnotations->addMatch(filterKey1);
-        renderPassFilterWithAnnotations->addMatch(filterKey2);
-        QTest::newRow("renderPassFilterWithAnnotations") << renderPassFilterWithAnnotations << QVector<Qt3DRender::QParameter *>() << filterKeys1;
-
-        Qt3DRender::QRenderPassFilter *renderPassFilterWithParamsAndAnnotations = new Qt3DRender::QRenderPassFilter();
-        Qt3DRender::QParameter *parameter3 = new Qt3DRender::QParameter(QStringLiteral("displacement"), 383.0f);
-        Qt3DRender::QParameter *parameter4 = new Qt3DRender::QParameter(QStringLiteral("torque"), 555);
-        Qt3DRender::QFilterKey *filterKey3 = new Qt3DRender::QFilterKey();
-        Qt3DRender::QFilterKey *filterKey4 = new Qt3DRender::QFilterKey();
-        filterKey3->setName(QStringLiteral("hasSuperCharger"));
-        filterKey3->setValue(false);
-        filterKey4->setName(QStringLiteral("hasNitroKit"));
-        filterKey4->setValue(true);
-        QVector<Qt3DRender::QParameter *> params2 = QVector<Qt3DRender::QParameter *>() << parameter3 << parameter4;
-        QVector<Qt3DRender::QFilterKey *> filterKeys2 = QVector<Qt3DRender::QFilterKey *>() << filterKey3 << filterKey4;
-        renderPassFilterWithParamsAndAnnotations->addParameter(parameter3);
-        renderPassFilterWithParamsAndAnnotations->addParameter(parameter4);
-        renderPassFilterWithParamsAndAnnotations->addMatch(filterKey3);
-        renderPassFilterWithParamsAndAnnotations->addMatch(filterKey4);
-        QTest::newRow("renderPassFilterWithParamsAndAnnotations") << renderPassFilterWithParamsAndAnnotations << params2 << filterKeys2 ;
-    }
-
-    // TODO: Avoid cloning here
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QRenderPassFilter*, renderPassFilter);
-        QFETCH(QVector<Qt3DRender::QParameter *>, parameters);
-        QFETCH(QVector<Qt3DRender::QFilterKey *>, filterKeys);
-
-        // THEN
-        QCOMPARE(renderPassFilter->parameters(), parameters);
-        QCOMPARE(renderPassFilter->matchAny(), filterKeys);
-
-        // WHEN
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(renderPassFilter);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + renderPassFilter->parameters().size() + renderPassFilter->matchAny().size());
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QRenderPassFilterData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderPassFilterData>>(creationChanges.first());
-        const Qt3DRender::QRenderPassFilterData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(renderPassFilter->id(), creationChangeData->subjectId());
-        QCOMPARE(renderPassFilter->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(renderPassFilter->metaObject(), creationChangeData->metaObject());
-
-        QCOMPARE(renderPassFilter->matchAny().count(), cloneData.matchIds.count());
-        QCOMPARE(renderPassFilter->parameters().count(), cloneData.parameterIds.count());
-
-        // TO DO: Add unit tests for QParameter / QFilterKey
-
-        delete renderPassFilter;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -150,30 +65,27 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(renderPassFilter.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         renderPassFilter->addParameter(param1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         renderPassFilter->removeParameter(param1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(renderPassFilter.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
@@ -181,30 +93,27 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(renderPassFilter.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         renderPassFilter->addMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         renderPassFilter->removeMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(renderPassFilter.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(renderPassFilter.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkParameterBookkeeping()
diff --git a/tests/auto/render/qrendersettings/tst_qrendersettings.cpp b/tests/auto/render/qrendersettings/tst_qrendersettings.cpp
index b58ab0947..51c53610e 100644
--- a/tests/auto/render/qrendersettings/tst_qrendersettings.cpp
+++ b/tests/auto/render/qrendersettings/tst_qrendersettings.cpp
@@ -33,9 +33,7 @@
 #include <Qt3DRender/private/qrendersettings_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QRenderSettings : public QObject
 {
@@ -171,74 +169,6 @@ private Q_SLOTS:
 
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QRenderSettings renderSettings;
-        Qt3DRender::QPickingSettings *pickingSettings = renderSettings.pickingSettings();
-        Qt3DRender::QViewport frameGraphRoot;
-
-        renderSettings.setRenderPolicy(Qt3DRender::QRenderSettings::OnDemand);
-        renderSettings.setActiveFrameGraph(&frameGraphRoot);
-        pickingSettings->setPickMethod(Qt3DRender::QPickingSettings::TrianglePicking);
-        pickingSettings->setPickResultMode(Qt3DRender::QPickingSettings::AllPicks);
-        pickingSettings->setFaceOrientationPickingMode(Qt3DRender::QPickingSettings::FrontAndBackFace);
-        pickingSettings->setWorldSpaceTolerance(5.f);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderSettings);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // RenderSettings + PickingSettings (because it's a QNode)
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderSettingsData>>(creationChanges.first());
-            const Qt3DRender::QRenderSettingsData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderSettings.pickingSettings()->pickMethod(), cloneData.pickMethod);
-            QCOMPARE(renderSettings.pickingSettings()->pickResultMode(), cloneData.pickResultMode);
-            QCOMPARE(renderSettings.pickingSettings()->faceOrientationPickingMode(), cloneData.faceOrientationPickingMode);
-            QCOMPARE(renderSettings.pickingSettings()->worldSpaceTolerance(), cloneData.pickWorldSpaceTolerance);
-            QCOMPARE(renderSettings.renderPolicy(), cloneData.renderPolicy);
-            QCOMPARE(renderSettings.activeFrameGraph()->id(), cloneData.activeFrameGraphId);
-            QCOMPARE(renderSettings.id(), creationChangeData->subjectId());
-            QCOMPARE(renderSettings.isEnabled(), true);
-            QCOMPARE(renderSettings.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderSettings.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        renderSettings.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderSettings);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // RenderSettings + PickingSettings (because it's a QNode)
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderSettingsData>>(creationChanges.first());
-            const Qt3DRender::QRenderSettingsData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderSettings.pickingSettings()->pickMethod(), cloneData.pickMethod);
-            QCOMPARE(renderSettings.pickingSettings()->pickResultMode(), cloneData.pickResultMode);
-            QCOMPARE(renderSettings.pickingSettings()->faceOrientationPickingMode(), cloneData.faceOrientationPickingMode);
-            QCOMPARE(renderSettings.renderPolicy(), cloneData.renderPolicy);
-            QCOMPARE(renderSettings.activeFrameGraph()->id(), cloneData.activeFrameGraphId);
-            QCOMPARE(renderSettings.id(), creationChangeData->subjectId());
-            QCOMPARE(renderSettings.isEnabled(), false);
-            QCOMPARE(renderSettings.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderSettings.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkRenderPolicyUpdate()
     {
         // GIVEN
@@ -252,11 +182,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSettings);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -265,8 +194,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -285,11 +213,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSettings);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -298,8 +225,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -319,11 +245,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSettings);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -332,8 +257,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -353,11 +277,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSettings);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -366,8 +289,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -387,11 +309,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSettings);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -400,8 +321,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -421,11 +341,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSettings);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSettings);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -434,8 +353,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qrenderstate/tst_qrenderstate.cpp b/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
index fb212bc8f..f18488f9a 100644
--- a/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
+++ b/tests/auto/render/qrenderstate/tst_qrenderstate.cpp
@@ -55,7 +55,7 @@
 #include <Qt3DRender/QStencilOperationArguments>
 #include <Qt3DRender/QClipPlane>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 using namespace Qt3DCore;
 using namespace Qt3DRender;
@@ -201,9 +201,8 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), frontend1);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), frontend1);
 
         // WHEN
         backend1->syncFromFrontEnd(frontend1, false);
@@ -211,7 +210,7 @@ private Q_SLOTS:
         // THEN
         QVERIFY(backend1->impl() == backend2->impl());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkStencilUpdates_data()
@@ -285,17 +284,14 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), frontend1);
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), frontend1);
 
         // WHEN
         backend1->syncFromFrontEnd(frontend1, false);
 
         // THEN
         QVERIFY(backend1->impl() == backend2->impl());
-
-        arbiter.events.clear();
     }
 };
 
diff --git a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
index 39f0c3c72..39b45ee42 100644
--- a/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
+++ b/tests/auto/render/qrenderstateset/tst_qrenderstateset.cpp
@@ -30,14 +30,13 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qrenderstateset.h>
 #include <Qt3DRender/private/qrenderstate_p.h>
 #include <Qt3DRender/qrenderstate.h>
 #include <Qt3DRender/private/qrenderstateset_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MyStateSet;
 class MyStateSetPrivate : public Qt3DRender::QRenderStatePrivate
@@ -73,56 +72,6 @@ private Q_SLOTS:
         QVERIFY(defaultstateSet->renderStates().isEmpty());
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QRenderStateSet *>("stateSet");
-        QTest::addColumn<QVector<Qt3DRender::QRenderState *> >("states");
-
-        Qt3DRender::QRenderStateSet *defaultConstructed = new Qt3DRender::QRenderStateSet();
-        QTest::newRow("defaultConstructed") << defaultConstructed << QVector<Qt3DRender::QRenderState *>();
-
-        Qt3DRender::QRenderStateSet *stateSetWithStates = new Qt3DRender::QRenderStateSet();
-        Qt3DRender::QRenderState *state1 = new MyStateSet();
-        Qt3DRender::QRenderState *state2 = new MyStateSet();
-        QVector<Qt3DRender::QRenderState *> states = QVector<Qt3DRender::QRenderState *>() << state1 << state2;
-        stateSetWithStates->addRenderState(state1);
-        stateSetWithStates->addRenderState(state2);
-        QTest::newRow("stateSetWithStates") << stateSetWithStates << states;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QRenderStateSet*, stateSet);
-        QFETCH(QVector<Qt3DRender::QRenderState *>, states);
-
-        // THEN
-        QCOMPARE(stateSet->renderStates(), states);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(stateSet);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + states.size());
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QRenderStateSetData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderStateSetData>>(creationChanges.first());
-        const Qt3DRender::QRenderStateSetData &cloneData = creationChangeData->data;
-
-        QCOMPARE(stateSet->id(), creationChangeData->subjectId());
-        QCOMPARE(stateSet->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(stateSet->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(stateSet->renderStates().count(), cloneData.renderStateIds.count());
-
-        for (int i = 0, m = states.count(); i < m; ++i) {
-            Qt3DRender::QRenderState *sOrig = states.at(i);
-            QCOMPARE(sOrig->id(), cloneData.renderStateIds.at(i));
-        }
-
-        delete stateSet;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -136,29 +85,26 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(stateSet.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(stateSet.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         stateSet->addRenderState(state1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
         // WHEN
         stateSet->removeRenderState(state1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QVERIFY(arbiter.dirtyNodes.contains(stateSet.data()));
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QVERIFY(arbiter.dirtyNodes().contains(stateSet.data()));
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkRenderStateBookkeeping()
diff --git a/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp b/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp
index a30617781..fa75e3580 100644
--- a/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp
+++ b/tests/auto/render/qrendersurfaceselector/tst_qrendersurfaceselector.cpp
@@ -33,9 +33,7 @@
 #include <Qt3DRender/qrendersurfaceselector.h>
 #include <Qt3DRender/private/qrendersurfaceselector_p.h>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QRenderSurfaceSelector: public QObject
 {
@@ -184,68 +182,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        QWindow newValue;
-        Qt3DRender::QRenderSurfaceSelector renderSurfaceSelector;
-
-        renderSurfaceSelector.setSurface(&newValue);
-        renderSurfaceSelector.setExternalRenderTargetSize(QSize(128, 128));
-        renderSurfaceSelector.setSurfacePixelRatio(25.0f);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderSurfaceSelector);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderSurfaceSelectorData>>(creationChanges.first());
-            const Qt3DRender::QRenderSurfaceSelectorData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderSurfaceSelector.surface(), cloneData.surface.data());
-            QCOMPARE(renderSurfaceSelector.externalRenderTargetSize(), cloneData.externalRenderTargetSize);
-            QCOMPARE(renderSurfaceSelector.surfacePixelRatio(), cloneData.surfacePixelRatio);
-            QCOMPARE(renderSurfaceSelector.id(), creationChangeData->subjectId());
-            QCOMPARE(renderSurfaceSelector.isEnabled(), true);
-            QCOMPARE(renderSurfaceSelector.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderSurfaceSelector.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        renderSurfaceSelector.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderSurfaceSelector);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderSurfaceSelectorData>>(creationChanges.first());
-            const Qt3DRender::QRenderSurfaceSelectorData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderSurfaceSelector.surface(), cloneData.surface.data());
-            QCOMPARE(renderSurfaceSelector.externalRenderTargetSize(), cloneData.externalRenderTargetSize);
-            QCOMPARE(renderSurfaceSelector.surfacePixelRatio(), cloneData.surfacePixelRatio);
-            QCOMPARE(renderSurfaceSelector.id(), creationChangeData->subjectId());
-            QCOMPARE(renderSurfaceSelector.isEnabled(), false);
-            QCOMPARE(renderSurfaceSelector.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderSurfaceSelector.metaObject(), creationChangeData->metaObject());
-        }
-
-        // Prevents crashes with temporary window being destroyed
-        renderSurfaceSelector.setSurface(nullptr);
-    }
-
     void checkSurfaceUpdate()
     {
         // GIVEN
@@ -260,11 +196,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSurfaceSelector);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSurfaceSelector);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -273,8 +208,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
         // Prevents crashes with temporary window being destroyed
@@ -294,11 +228,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSurfaceSelector);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSurfaceSelector);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -307,8 +240,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -326,11 +258,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderSurfaceSelector);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderSurfaceSelector);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -339,8 +270,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qrendertarget/tst_qrendertarget.cpp b/tests/auto/render/qrendertarget/tst_qrendertarget.cpp
index ad9d5f329..3377e6f8f 100644
--- a/tests/auto/render/qrendertarget/tst_qrendertarget.cpp
+++ b/tests/auto/render/qrendertarget/tst_qrendertarget.cpp
@@ -32,9 +32,7 @@
 #include <Qt3DRender/private/qrendertarget_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QRenderTarget : public QObject
 {
@@ -95,62 +93,6 @@ private Q_SLOTS:
         QCOMPARE(renderTarget.outputs().size(), 0);
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QRenderTarget renderTarget;
-        Qt3DRender::QRenderTargetOutput output;
-
-        renderTarget.addOutput(&output);
-
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderTarget);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // Target + Output
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderTargetData>>(creationChanges.first());
-            const Qt3DRender::QRenderTargetData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderTarget.id(), creationChangeData->subjectId());
-            QCOMPARE(renderTarget.isEnabled(), true);
-            QCOMPARE(renderTarget.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderTarget.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(renderTarget.outputs().size(), cloneData.outputIds.size());
-            QCOMPARE(output.id(), cloneData.outputIds.first());
-        }
-
-        // WHEN
-        renderTarget.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderTarget);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // Target + Output
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderTargetData>>(creationChanges.first());
-            const Qt3DRender::QRenderTargetData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderTarget.id(), creationChangeData->subjectId());
-            QCOMPARE(renderTarget.isEnabled(), false);
-            QCOMPARE(renderTarget.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderTarget.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(renderTarget.outputs().size(), cloneData.outputIds.size());
-            QCOMPARE(output.id(), cloneData.outputIds.first());
-        }
-    }
-
     void checkRenderTargetOutputUpdate()
     {
         // GIVEN
@@ -165,11 +107,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderTarget);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderTarget);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -178,11 +119,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderTarget);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderTarget);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 };
diff --git a/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp b/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp
index 55733f0f3..0fed1d7bb 100644
--- a/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp
+++ b/tests/auto/render/qrendertargetoutput/tst_qrendertargetoutput.cpp
@@ -34,9 +34,7 @@
 #include <Qt3DRender/qabstracttexture.h>
 #include <Qt3DRender/qtexture.h>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QRenderTargetOutput : public QObject
 {
@@ -170,69 +168,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QRenderTargetOutput renderTargetOutput;
-
-        renderTargetOutput.setAttachmentPoint(Qt3DRender::QRenderTargetOutput::Color5);
-        renderTargetOutput.setMipLevel(10);
-        renderTargetOutput.setLayer(2);
-        renderTargetOutput.setFace(Qt3DRender::QAbstractTexture::CubeMapNegativeY);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderTargetOutput);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderTargetOutputData>>(creationChanges.first());
-            const Qt3DRender::QRenderTargetOutputData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderTargetOutput.attachmentPoint(), cloneData.attachmentPoint);
-            QCOMPARE(Qt3DCore::QNodeId(), cloneData.textureId);
-            QCOMPARE(renderTargetOutput.mipLevel(), cloneData.mipLevel);
-            QCOMPARE(renderTargetOutput.layer(), cloneData.layer);
-            QCOMPARE(renderTargetOutput.face(), cloneData.face);
-            QCOMPARE(renderTargetOutput.id(), creationChangeData->subjectId());
-            QCOMPARE(renderTargetOutput.isEnabled(), true);
-            QCOMPARE(renderTargetOutput.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderTargetOutput.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        renderTargetOutput.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&renderTargetOutput);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderTargetOutputData>>(creationChanges.first());
-            const Qt3DRender::QRenderTargetOutputData cloneData = creationChangeData->data;
-
-            QCOMPARE(renderTargetOutput.attachmentPoint(), cloneData.attachmentPoint);
-            QCOMPARE(Qt3DCore::QNodeId(), cloneData.textureId);
-            QCOMPARE(renderTargetOutput.mipLevel(), cloneData.mipLevel);
-            QCOMPARE(renderTargetOutput.layer(), cloneData.layer);
-            QCOMPARE(renderTargetOutput.face(), cloneData.face);
-            QCOMPARE(renderTargetOutput.id(), creationChangeData->subjectId());
-            QCOMPARE(renderTargetOutput.isEnabled(), false);
-            QCOMPARE(renderTargetOutput.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(renderTargetOutput.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkAttachmentPointUpdate()
     {
         // GIVEN
@@ -246,11 +181,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderTargetOutput);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -259,8 +193,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -279,11 +212,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderTargetOutput);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -292,8 +224,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -311,11 +242,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderTargetOutput);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -324,8 +254,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -343,11 +272,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderTargetOutput);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -356,8 +284,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -375,11 +302,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &renderTargetOutput);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &renderTargetOutput);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -388,8 +314,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
index 7bacc3b6d..af5b29bd2 100644
--- a/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
+++ b/tests/auto/render/qrendertargetselector/tst_qrendertargetselector.cpp
@@ -30,12 +30,11 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qrendertargetselector.h>
 #include <Qt3DRender/private/qrendertargetselector_p.h>
 #include <Qt3DRender/qrendertarget.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QRenderTargetSelector: public QObject
 {
@@ -51,59 +50,6 @@ private Q_SLOTS:
         QCOMPARE(defaultTargetSelector->outputs().count(), 0);
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QRenderTargetSelector *>("renderTargetSelector");
-        QTest::addColumn<QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> >("outputs");
-        QTest::addColumn<Qt3DRender::QRenderTarget * >("target");
-
-        Qt3DRender::QRenderTargetSelector *defaultConstructed = new Qt3DRender::QRenderTargetSelector();
-        QTest::newRow("defaultConstructed") << defaultConstructed << QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>() << static_cast<Qt3DRender::QRenderTarget *>(nullptr);
-
-        Qt3DRender::QRenderTargetSelector *renderTargetSelectorWithTarget = new Qt3DRender::QRenderTargetSelector();
-        Qt3DRender::QRenderTarget *target1 = new Qt3DRender::QRenderTarget();
-        renderTargetSelectorWithTarget->setTarget(target1);
-        QTest::newRow("renderTargetSelectorWithTarget") << renderTargetSelectorWithTarget << QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>() << target1;
-
-        Qt3DRender::QRenderTargetSelector *renderTargetSelectorWithTargetAndBuffers = new Qt3DRender::QRenderTargetSelector();
-        Qt3DRender::QRenderTarget *target2 = new Qt3DRender::QRenderTarget();
-        renderTargetSelectorWithTargetAndBuffers->setTarget(target2);
-        QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> attachmentPoints = QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>() << Qt3DRender::QRenderTargetOutput::Color0 << Qt3DRender::QRenderTargetOutput::Depth;
-        renderTargetSelectorWithTargetAndBuffers->setOutputs(attachmentPoints);
-        QTest::newRow("renderTargetSelectorWithTargetAndDrawBuffers") << renderTargetSelectorWithTargetAndBuffers << attachmentPoints << target2;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QRenderTargetSelector*, renderTargetSelector);
-        QFETCH(QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>, outputs);
-        QFETCH(Qt3DRender::QRenderTarget *, target);
-
-        // THEN
-        QCOMPARE(renderTargetSelector->outputs(), outputs);
-        QCOMPARE(renderTargetSelector->target(), target);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(renderTargetSelector);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + (renderTargetSelector->target() ? 1 : 0));
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QRenderTargetSelectorData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QRenderTargetSelectorData>>(creationChanges.first());
-        const Qt3DRender::QRenderTargetSelectorData &cloneData = creationChangeData->data;
-
-        // THEN
-        QCOMPARE(renderTargetSelector->id(), creationChangeData->subjectId());
-        QCOMPARE(renderTargetSelector->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(renderTargetSelector->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(renderTargetSelector->target() ? renderTargetSelector->target()->id() : Qt3DCore::QNodeId(), cloneData.targetId);
-
-        delete renderTargetSelector;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -117,30 +63,27 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), renderTargetSelector.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         renderTargetSelector->setTarget(target);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         renderTargetSelector->setTarget(nullptr);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), renderTargetSelector.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint> outputs;
@@ -149,30 +92,27 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), renderTargetSelector.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
 
         // WHEN
         renderTargetSelector->setOutputs(outputs);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         renderTargetSelector->setOutputs(QVector<Qt3DRender::QRenderTargetOutput::AttachmentPoint>());
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), renderTargetSelector.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), renderTargetSelector.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkRenderTargetBookkeeping()
diff --git a/tests/auto/render/qscene2d/tst_qscene2d.cpp b/tests/auto/render/qscene2d/tst_qscene2d.cpp
index 583da6eaf..3a9c0bc71 100644
--- a/tests/auto/render/qscene2d/tst_qscene2d.cpp
+++ b/tests/auto/render/qscene2d/tst_qscene2d.cpp
@@ -32,9 +32,7 @@
 #include <private/qscene2d_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 using namespace Qt3DRender::Quick;
 
@@ -148,65 +146,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::Quick::QScene2D scene2d;
-        QScopedPointer<Qt3DRender::QRenderTargetOutput> output(new Qt3DRender::QRenderTargetOutput());
-
-        scene2d.setOutput(output.data());
-        scene2d.setRenderPolicy(QScene2D::SingleShot);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&scene2d);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<
-                    Qt3DRender::Quick::QScene2DData>>(creationChanges.first());
-            const Qt3DRender::Quick::QScene2DData cloneData = creationChangeData->data;
-
-            QCOMPARE(scene2d.output()->id(), cloneData.output);
-            QCOMPARE(scene2d.renderPolicy(), cloneData.renderPolicy);
-            QCOMPARE(scene2d.id(), creationChangeData->subjectId());
-            QCOMPARE(scene2d.isEnabled(), true);
-            QCOMPARE(scene2d.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(scene2d.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(scene2d.isMouseEnabled(), cloneData.mouseEnabled);
-        }
-
-        // WHEN
-        scene2d.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&scene2d);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<
-                    Qt3DRender::Quick::QScene2DData>>(creationChanges.first());
-            const Qt3DRender::Quick::QScene2DData cloneData = creationChangeData->data;
-
-            QCOMPARE(scene2d.output()->id(), cloneData.output);
-            QCOMPARE(scene2d.renderPolicy(), cloneData.renderPolicy);
-            QCOMPARE(scene2d.id(), creationChangeData->subjectId());
-            QCOMPARE(scene2d.isEnabled(), false);
-            QCOMPARE(scene2d.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(scene2d.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkOutputUpdate()
     {
         // GIVEN
@@ -221,11 +160,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &scene2d);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &scene2d);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -234,8 +172,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -253,11 +190,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &scene2d);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &scene2d);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -266,8 +202,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -285,11 +220,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &scene2d);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &scene2d);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -298,8 +232,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qsceneloader/tst_qsceneloader.cpp b/tests/auto/render/qsceneloader/tst_qsceneloader.cpp
index 79ca6a291..b237f2dd4 100644
--- a/tests/auto/render/qsceneloader/tst_qsceneloader.cpp
+++ b/tests/auto/render/qsceneloader/tst_qsceneloader.cpp
@@ -30,7 +30,6 @@
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/qtransform.h>
 
 #include <Qt3DRender/qsceneloader.h>
@@ -41,7 +40,7 @@
 #include <Qt3DRender/private/qsceneloader_p.h>
 #include <QSignalSpy>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QSceneLoader: public QObject
 {
@@ -60,62 +59,6 @@ private Q_SLOTS:
         QVERIFY(static_cast<Qt3DRender::QSceneLoaderPrivate *>(Qt3DCore::QNodePrivate::get(&sceneLoader))->m_subTreeRoot == nullptr);
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QSceneLoader sceneLoader;
-        const QUrl sceneUrl = QUrl(QStringLiteral("LA ConventionCenter"));
-        sceneLoader.setSource(sceneUrl);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&sceneLoader);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData =
-                    qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QSceneLoaderData>>(creationChanges.first());
-            const Qt3DRender::QSceneLoaderData cloneData = creationChangeData->data;
-
-            QCOMPARE(sceneLoader.id(), creationChangeData->subjectId());
-            QCOMPARE(sceneLoader.isEnabled(), true);
-            QCOMPARE(sceneLoader.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(sceneLoader.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(sceneLoader.source(), sceneUrl);
-            QCOMPARE(sceneLoader.source(), cloneData.source);
-        }
-
-        // WHEN
-        sceneLoader.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&sceneLoader);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData =
-                    qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QSceneLoaderData>>(creationChanges.first());
-            const Qt3DRender::QSceneLoaderData cloneData = creationChangeData->data;
-
-            QCOMPARE(sceneLoader.id(), creationChangeData->subjectId());
-            QCOMPARE(sceneLoader.isEnabled(), false);
-            QCOMPARE(sceneLoader.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(sceneLoader.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(sceneLoader.source(), sceneUrl);
-            QCOMPARE(sceneLoader.source(), cloneData.source);
-        }
-    }
-
     void checkSourcePropertyUpdate()
     {
         // GIVEN
@@ -129,11 +72,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), sceneLoader.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), sceneLoader.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkEntities()
diff --git a/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp b/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp
index 2fe515436..e12872d6c 100644
--- a/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp
+++ b/tests/auto/render/qscreenraycaster/tst_qscreenraycaster.cpp
@@ -32,7 +32,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DRender/QScreenRayCaster>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MyRayCaster : public Qt3DRender::QScreenRayCaster
 {
@@ -44,11 +44,6 @@ public:
         qRegisterMetaType<Qt3DRender::QAbstractRayCaster::Hits>("Hits");
     }
 
-    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) final
-    {
-        Qt3DRender::QScreenRayCaster::sceneChangeEvent(change);
-    }
-
 private:
     friend class tst_RayCaster;
 };
@@ -103,11 +98,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), rayCaster.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), rayCaster.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 
     void checkBackendUpdates_data()
diff --git a/tests/auto/render/qsetfence/tst_qsetfence.cpp b/tests/auto/render/qsetfence/tst_qsetfence.cpp
index ad92e9fe0..0c74c6e83 100644
--- a/tests/auto/render/qsetfence/tst_qsetfence.cpp
+++ b/tests/auto/render/qsetfence/tst_qsetfence.cpp
@@ -37,25 +37,17 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
 #include <Qt3DRender/qsetfence.h>
 #include <Qt3DRender/private/qsetfence_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class MySetFence : public Qt3DRender::QSetFence
 {
 public:
-    using Qt3DRender::QSetFence::sceneChangeEvent;
 };
 
 class tst_QSetFence : public QObject
@@ -95,10 +87,8 @@ private Q_SLOTS:
             QVERIFY(spy.isValid());
 
             // THEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("handleType");
-            valueChange->setValue(QVariant::fromValue(Qt3DRender::QSetFence::OpenGLFenceId));
-            setFence.sceneChangeEvent(valueChange);
+            auto *dNode = static_cast<Qt3DRender::QSetFencePrivate *>(Qt3DRender::QSetFencePrivate::get(&setFence));
+            dNode->setHandleType(Qt3DRender::QSetFence::OpenGLFenceId);
 
             // THEN
             QCOMPARE(setFence.handleType(), Qt3DRender::QSetFence::OpenGLFenceId);
@@ -106,7 +96,7 @@ private Q_SLOTS:
 
             // WHEN
             spy.clear();
-            setFence.sceneChangeEvent(valueChange);
+            dNode->setHandleType(Qt3DRender::QSetFence::OpenGLFenceId);
 
             // THEN
             QCOMPARE(spy.count(), 0);
@@ -120,10 +110,8 @@ private Q_SLOTS:
             QVERIFY(spy.isValid());
 
             // WHEN
-            Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-            valueChange->setPropertyName("handle");
-            valueChange->setValue(QVariant(984));
-            setFence.sceneChangeEvent(valueChange);
+            auto *dNode = static_cast<Qt3DRender::QSetFencePrivate *>(Qt3DRender::QSetFencePrivate::get(&setFence));
+            dNode->setHandle(QVariant(984));
 
             // THEN
             QCOMPARE(setFence.handle(),QVariant(984));
@@ -131,60 +119,12 @@ private Q_SLOTS:
 
             // WHEN
             spy.clear();
-            setFence.sceneChangeEvent(valueChange);
+            dNode->setHandle(QVariant(984));
 
             // THEN
             QCOMPARE(spy.count(), 0);
         }
     }
-
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QSetFence setFence;
-
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&setFence);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QSetFenceData>>(creationChanges.first());
-
-            QCOMPARE(setFence.id(), creationChangeData->subjectId());
-            QCOMPARE(setFence.isEnabled(), true);
-            QCOMPARE(setFence.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(setFence.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        setFence.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&setFence);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QSetFenceData>>(creationChanges.first());
-
-            QCOMPARE(setFence.id(), creationChangeData->subjectId());
-            QCOMPARE(setFence.isEnabled(), false);
-            QCOMPARE(setFence.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(setFence.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
 };
 
 QTEST_MAIN(tst_QSetFence)
diff --git a/tests/auto/render/qshaderimage/tst_qshaderimage.cpp b/tests/auto/render/qshaderimage/tst_qshaderimage.cpp
index 436d81192..cc5081063 100644
--- a/tests/auto/render/qshaderimage/tst_qshaderimage.cpp
+++ b/tests/auto/render/qshaderimage/tst_qshaderimage.cpp
@@ -43,9 +43,7 @@
 #include <Qt3DRender/private/qshaderimage_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QShaderImage : public QObject
 {
@@ -194,76 +192,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QShaderImage shaderImage;
-        Qt3DRender::QTexture2D t;
-
-        shaderImage.setTexture(&t);
-        shaderImage.setLayered(true);
-        shaderImage.setMipLevel(883);
-        shaderImage.setLayer(1584);
-        shaderImage.setAccess(Qt3DRender::QShaderImage::WriteOnly);
-        shaderImage.setFormat(Qt3DRender::QShaderImage::R32F);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&shaderImage);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            // ShaderImage + Texture creation
-            QCOMPARE(creationChanges.size(), 2);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderImageData>>(creationChanges.first());
-            const Qt3DRender::QShaderImageData cloneData = creationChangeData->data;
-
-            QCOMPARE(shaderImage.texture()->id(), cloneData.textureId);
-            QCOMPARE(shaderImage.layered(), cloneData.layered);
-            QCOMPARE(shaderImage.mipLevel(), cloneData.mipLevel);
-            QCOMPARE(shaderImage.layer(), cloneData.layer);
-            QCOMPARE(shaderImage.access(), cloneData.access);
-            QCOMPARE(shaderImage.format(), cloneData.format);
-            QCOMPARE(shaderImage.id(), creationChangeData->subjectId());
-            QCOMPARE(shaderImage.isEnabled(), true);
-            QCOMPARE(shaderImage.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(shaderImage.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        shaderImage.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&shaderImage);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            // ShaderImage + Texture creation
-            QCOMPARE(creationChanges.size(), 2);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderImageData>>(creationChanges.first());
-            const Qt3DRender::QShaderImageData cloneData = creationChangeData->data;
-
-            QCOMPARE(shaderImage.texture()->id(), cloneData.textureId);
-            QCOMPARE(shaderImage.layered(), cloneData.layered);
-            QCOMPARE(shaderImage.mipLevel(), cloneData.mipLevel);
-            QCOMPARE(shaderImage.layer(), cloneData.layer);
-            QCOMPARE(shaderImage.access(), cloneData.access);
-            QCOMPARE(shaderImage.format(), cloneData.format);
-            QCOMPARE(shaderImage.id(), creationChangeData->subjectId());
-            QCOMPARE(shaderImage.isEnabled(), false);
-            QCOMPARE(shaderImage.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(shaderImage.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkTextureUpdate()
     {
         // GIVEN
@@ -278,11 +206,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -291,8 +218,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -310,11 +236,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -323,8 +248,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -342,11 +266,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -355,8 +278,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -374,11 +296,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -387,8 +308,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -406,11 +326,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -419,8 +338,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -438,11 +356,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderImage);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -451,8 +368,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
index 15be26e8e..b7aa7f8de 100644
--- a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
+++ b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
@@ -26,19 +26,12 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
 #include <Qt3DRender/qshaderprogram.h>
 #include <Qt3DRender/private/qshaderprogram_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 // We need to call QShaderProgram::sceneChangeEvent
 class tst_QShaderProgram : public Qt3DRender::QShaderProgram
@@ -211,75 +204,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QShaderProgram shaderProgram;
-
-        shaderProgram.setVertexShaderCode(QByteArrayLiteral("Vertex"));
-        shaderProgram.setTessellationControlShaderCode(QByteArrayLiteral("TesselControl"));
-        shaderProgram.setTessellationEvaluationShaderCode(QByteArrayLiteral("TesselEval"));
-        shaderProgram.setGeometryShaderCode(QByteArrayLiteral("Geometry"));
-        shaderProgram.setFragmentShaderCode(QByteArrayLiteral("Fragment"));
-        shaderProgram.setComputeShaderCode(QByteArrayLiteral("Compute"));
-        shaderProgram.setFormat(QShaderProgram::SPIRV);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&shaderProgram);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderProgramData>>(creationChanges.first());
-            const Qt3DRender::QShaderProgramData cloneData = creationChangeData->data;
-
-            QCOMPARE(shaderProgram.vertexShaderCode(), cloneData.vertexShaderCode);
-            QCOMPARE(shaderProgram.tessellationControlShaderCode(), cloneData.tessellationControlShaderCode);
-            QCOMPARE(shaderProgram.tessellationEvaluationShaderCode(), cloneData.tessellationEvaluationShaderCode);
-            QCOMPARE(shaderProgram.geometryShaderCode(), cloneData.geometryShaderCode);
-            QCOMPARE(shaderProgram.fragmentShaderCode(), cloneData.fragmentShaderCode);
-            QCOMPARE(shaderProgram.computeShaderCode(), cloneData.computeShaderCode);
-            QCOMPARE(shaderProgram.format(), cloneData.format);
-            QCOMPARE(shaderProgram.id(), creationChangeData->subjectId());
-            QCOMPARE(shaderProgram.isEnabled(), true);
-            QCOMPARE(shaderProgram.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(shaderProgram.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        shaderProgram.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&shaderProgram);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderProgramData>>(creationChanges.first());
-            const Qt3DRender::QShaderProgramData cloneData = creationChangeData->data;
-
-            QCOMPARE(shaderProgram.vertexShaderCode(), cloneData.vertexShaderCode);
-            QCOMPARE(shaderProgram.tessellationControlShaderCode(), cloneData.tessellationControlShaderCode);
-            QCOMPARE(shaderProgram.tessellationEvaluationShaderCode(), cloneData.tessellationEvaluationShaderCode);
-            QCOMPARE(shaderProgram.geometryShaderCode(), cloneData.geometryShaderCode);
-            QCOMPARE(shaderProgram.fragmentShaderCode(), cloneData.fragmentShaderCode);
-            QCOMPARE(shaderProgram.computeShaderCode(), cloneData.computeShaderCode);
-            QCOMPARE(shaderProgram.id(), creationChangeData->subjectId());
-            QCOMPARE(shaderProgram.isEnabled(), false);
-            QCOMPARE(shaderProgram.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(shaderProgram.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkVertexShaderCodeUpdate()
     {
         // GIVEN
@@ -293,11 +217,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderProgram);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -306,8 +229,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -325,11 +247,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderProgram);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -338,8 +259,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -357,11 +277,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderProgram);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -370,8 +289,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -389,11 +307,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderProgram);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -402,8 +319,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -421,11 +337,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderProgram);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -434,8 +349,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -453,11 +367,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &shaderProgram);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &shaderProgram);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -466,8 +379,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -484,23 +396,21 @@ private Q_SLOTS:
         QVERIFY(spy.isValid());
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        valueChange->setPropertyName("log");
-        valueChange->setValue(QVariant::fromValue(logValue));
-        sceneChangeEvent(valueChange);
+        auto *dNode = static_cast<Qt3DRender::QShaderProgramPrivate *>(Qt3DCore::QNodePrivate::get(this));
+        dNode->setLog(logValue);
 
         // THEN
         QCOMPARE(spy.count(), 1);
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
         QCOMPARE(log(), logValue);
 
         // WHEN
         spy.clear();
-        sceneChangeEvent(valueChange);
+        dNode->setLog(logValue);
 
         // THEN
         QCOMPARE(spy.count(), 0);
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
         QCOMPARE(log(), logValue);
 
         // Cleanup
@@ -520,23 +430,21 @@ private Q_SLOTS:
         QVERIFY(spy.isValid());
 
         // WHEN
-        Qt3DCore::QPropertyUpdatedChangePtr valueChange(new Qt3DCore::QPropertyUpdatedChange(Qt3DCore::QNodeId()));
-        valueChange->setPropertyName("status");
-        valueChange->setValue(QVariant::fromValue(newStatus));
-        sceneChangeEvent(valueChange);
+        auto *dNode = static_cast<Qt3DRender::QShaderProgramPrivate *>(Qt3DCore::QNodePrivate::get(this));
+        dNode->setStatus(newStatus);
 
         // THEN
         QCOMPARE(spy.count(), 1);
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
         QCOMPARE(status(), newStatus);
 
         // WHEN
         spy.clear();
-        sceneChangeEvent(valueChange);
+        dNode->setStatus(newStatus);
 
         // THEN
         QCOMPARE(spy.count(), 0);
-        QCOMPARE(arbiter.events.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
         QCOMPARE(status(), newStatus);
 
         // Cleanup
@@ -581,7 +489,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(spy.count(), 1);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
 
             spy.clear();
         }
@@ -593,7 +501,7 @@ private Q_SLOTS:
 
             // THEN
             QCOMPARE(spy.count(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
         }
     }
 
diff --git a/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp b/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
index 851316e60..484eca943 100644
--- a/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
+++ b/tests/auto/render/qshaderprogrambuilder/tst_qshaderprogrambuilder.cpp
@@ -33,10 +33,7 @@
 #include <Qt3DRender/private/qshaderprogrambuilder_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/qpropertyupdatedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QShaderProgramBuilder : public Qt3DRender::QShaderProgramBuilder
 {
@@ -264,79 +261,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QShaderProgramBuilder builder;
-
-        builder.setShaderProgram(new Qt3DRender::QShaderProgram(&builder));
-        builder.setEnabledLayers({"foo", "bar"});
-        builder.setVertexShaderGraph(QUrl::fromEncoded("qrc:/vertex.json"));
-        builder.setTessellationControlShaderGraph(QUrl::fromEncoded("qrc:/tesscontrol.json"));
-        builder.setTessellationEvaluationShaderGraph(QUrl::fromEncoded("qrc:/tesseval.json"));
-        builder.setGeometryShaderGraph(QUrl::fromEncoded("qrc:/geometry.json"));
-        builder.setFragmentShaderGraph(QUrl::fromEncoded("qrc:/fragment.json"));
-        builder.setComputeShaderGraph(QUrl::fromEncoded("qrc:/compute.json"));
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&builder);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // second one is for the shader program child
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderProgramBuilderData>>(creationChanges.first());
-            const Qt3DRender::QShaderProgramBuilderData cloneData = creationChangeData->data;
-
-            QCOMPARE(builder.shaderProgram()->id(), cloneData.shaderProgramId);
-            QCOMPARE(builder.enabledLayers(), cloneData.enabledLayers);
-            QCOMPARE(builder.vertexShaderGraph(), cloneData.vertexShaderGraph);
-            QCOMPARE(builder.tessellationControlShaderGraph(), cloneData.tessellationControlShaderGraph);
-            QCOMPARE(builder.tessellationEvaluationShaderGraph(), cloneData.tessellationEvaluationShaderGraph);
-            QCOMPARE(builder.geometryShaderGraph(), cloneData.geometryShaderGraph);
-            QCOMPARE(builder.fragmentShaderGraph(), cloneData.fragmentShaderGraph);
-            QCOMPARE(builder.computeShaderGraph(), cloneData.computeShaderGraph);
-            QCOMPARE(builder.id(), creationChangeData->subjectId());
-            QCOMPARE(builder.isEnabled(), true);
-            QCOMPARE(builder.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(builder.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        builder.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&builder);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 2); // second one is for the shader program child
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QShaderProgramBuilderData>>(creationChanges.first());
-            const Qt3DRender::QShaderProgramBuilderData cloneData = creationChangeData->data;
-
-            QCOMPARE(builder.shaderProgram()->id(), cloneData.shaderProgramId);
-            QCOMPARE(builder.enabledLayers(), cloneData.enabledLayers);
-            QCOMPARE(builder.vertexShaderGraph(), cloneData.vertexShaderGraph);
-            QCOMPARE(builder.tessellationControlShaderGraph(), cloneData.tessellationControlShaderGraph);
-            QCOMPARE(builder.tessellationEvaluationShaderGraph(), cloneData.tessellationEvaluationShaderGraph);
-            QCOMPARE(builder.geometryShaderGraph(), cloneData.geometryShaderGraph);
-            QCOMPARE(builder.fragmentShaderGraph(), cloneData.fragmentShaderGraph);
-            QCOMPARE(builder.computeShaderGraph(), cloneData.computeShaderGraph);
-            QCOMPARE(builder.id(), creationChangeData->subjectId());
-            QCOMPARE(builder.isEnabled(), false);
-            QCOMPARE(builder.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(builder.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkShaderProgramUpdate()
     {
         // GIVEN
@@ -351,11 +275,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -364,8 +287,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -383,11 +305,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -396,8 +317,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -414,11 +334,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -427,8 +346,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -446,11 +364,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -459,8 +376,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -478,11 +394,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -491,8 +406,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -510,11 +424,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -523,8 +436,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -542,11 +454,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -555,8 +466,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -574,11 +484,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &builder);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &builder);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -587,8 +496,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
diff --git a/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp b/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp
index 3187dbd52..f7185320b 100644
--- a/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp
+++ b/tests/auto/render/qsharedgltexture/tst_qsharedgltexture.cpp
@@ -35,9 +35,7 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DRender/private/qtexture_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QSharedGLTexture : public QObject
 {
@@ -81,58 +79,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QSharedGLTexture glTexture;
-
-        glTexture.setTextureId(1200);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&glTexture);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureData cloneData = creationChangeData->data;
-
-            QCOMPARE(glTexture.id(), creationChangeData->subjectId());
-            QCOMPARE(glTexture.isEnabled(), true);
-            QCOMPARE(glTexture.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(glTexture.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.sharedTextureId, 1200);
-        }
-
-        // WHEN
-        glTexture.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&glTexture);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureData cloneData = creationChangeData->data;
-
-            QCOMPARE(glTexture.id(), creationChangeData->subjectId());
-            QCOMPARE(glTexture.isEnabled(), false);
-            QCOMPARE(glTexture.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(glTexture.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(cloneData.sharedTextureId, 1200);
-        }
-    }
-
     void checkTextureIdUpdate()
     {
         // GIVEN
@@ -146,11 +92,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &glTexture);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &glTexture);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -159,8 +104,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp b/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
index 66c625cfc..02bbeffd8 100644
--- a/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
+++ b/tests/auto/render/qsortpolicy/tst_qsortpolicy.cpp
@@ -30,14 +30,11 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/qpropertyvalueaddedchange.h>
-#include <Qt3DCore/qpropertyvalueremovedchange.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qsortpolicy.h>
 #include <Qt3DRender/private/qsortpolicy_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 // We need to call QNode::clone which is protected
 // So we sublcass QNode instead of QObject
@@ -54,51 +51,6 @@ private Q_SLOTS:
         QVERIFY(defaultsortPolicy->sortTypes().isEmpty());
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QSortPolicy *>("sortPolicy");
-        QTest::addColumn<QVector<Qt3DRender::QSortPolicy::SortType> >("sortTypes");
-
-        Qt3DRender::QSortPolicy *defaultConstructed = new Qt3DRender::QSortPolicy();
-        QTest::newRow("defaultConstructed") << defaultConstructed << QVector<Qt3DRender::QSortPolicy::SortType>();
-
-        Qt3DRender::QSortPolicy *sortPolicyWithSortTypes = new Qt3DRender::QSortPolicy();
-        auto sortTypes = QVector<Qt3DRender::QSortPolicy::SortType>() << Qt3DRender::QSortPolicy::BackToFront
-                                                                      << Qt3DRender::QSortPolicy::Material
-                                                                      << Qt3DRender::QSortPolicy::FrontToBack;
-        sortPolicyWithSortTypes->setSortTypes(sortTypes);
-        QTest::newRow("sortPolicyWithSortTypes") << sortPolicyWithSortTypes << sortTypes ;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QSortPolicy*, sortPolicy);
-        QFETCH(QVector<Qt3DRender::QSortPolicy::SortType>, sortTypes);
-
-        // THEN
-        QCOMPARE(sortPolicy->sortTypes(), sortTypes);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(sortPolicy);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QSortPolicyData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QSortPolicyData>>(creationChanges.first());
-        const Qt3DRender::QSortPolicyData &cloneData = creationChangeData->data;
-
-        QCOMPARE(sortPolicy->id(), creationChangeData->subjectId());
-        QCOMPARE(sortPolicy->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(sortPolicy->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(sortPolicy->sortTypes().count(), cloneData.sortTypes.count());
-        QCOMPARE(sortPolicy->sortTypes(), cloneData.sortTypes);
-
-        delete sortPolicy;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -117,11 +69,10 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), sortPolicy.data());
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), sortPolicy.data());
 
-        arbiter.dirtyNodes.clear();
+        arbiter.clear();
     }
 };
 
diff --git a/tests/auto/render/qtechnique/tst_qtechnique.cpp b/tests/auto/render/qtechnique/tst_qtechnique.cpp
index 40d763ad4..4a344c9d0 100644
--- a/tests/auto/render/qtechnique/tst_qtechnique.cpp
+++ b/tests/auto/render/qtechnique/tst_qtechnique.cpp
@@ -37,9 +37,7 @@
 #include <Qt3DRender/private/qtechnique_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QTechnique : public QObject
 {
@@ -233,85 +231,6 @@ private Q_SLOTS:
         QCOMPARE(technique.filterKeys().size(), 0);
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QTechnique technique;
-        Qt3DRender::QRenderPass pass;
-        Qt3DRender::QParameter parameter;
-        Qt3DRender::QFilterKey filterKey;
-
-        technique.addRenderPass(&pass);
-        technique.addParameter(&parameter);
-        technique.addFilterKey(&filterKey);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&technique);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 4); // Technique + Pass + Parameter + FilterKey
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QTechniqueData>>(creationChanges.first());
-            const Qt3DRender::QTechniqueData cloneData = creationChangeData->data;
-
-            QCOMPARE(technique.graphicsApiFilter()->minorVersion(), cloneData.graphicsApiFilterData.m_minor);
-            QCOMPARE(technique.graphicsApiFilter()->majorVersion(), cloneData.graphicsApiFilterData.m_major);
-            QCOMPARE(technique.graphicsApiFilter()->profile(), cloneData.graphicsApiFilterData.m_profile);
-            QCOMPARE(technique.graphicsApiFilter()->vendor(), cloneData.graphicsApiFilterData.m_vendor);
-            QCOMPARE(technique.graphicsApiFilter()->extensions(), cloneData.graphicsApiFilterData.m_extensions);
-            QCOMPARE(technique.graphicsApiFilter()->api(), cloneData.graphicsApiFilterData.m_api);
-            QCOMPARE(technique.id(), creationChangeData->subjectId());
-            QCOMPARE(technique.isEnabled(), true);
-            QCOMPARE(technique.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(technique.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(technique.renderPasses().size(), cloneData.renderPassIds.size());
-            QCOMPARE(technique.parameters().size(), cloneData.parameterIds.size());
-            QCOMPARE(technique.filterKeys().size(), cloneData.filterKeyIds.size());
-            QCOMPARE(pass.id(), cloneData.renderPassIds.first());
-            QCOMPARE(parameter.id(), cloneData.parameterIds.first());
-            QCOMPARE(filterKey.id(), cloneData.filterKeyIds.first());
-        }
-
-        // WHEN
-        technique.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&technique);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 4); // Technique + Pass + Parameter + FilterKey
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QTechniqueData>>(creationChanges.first());
-            const Qt3DRender::QTechniqueData cloneData = creationChangeData->data;
-
-            QCOMPARE(technique.graphicsApiFilter()->minorVersion(), cloneData.graphicsApiFilterData.m_minor);
-            QCOMPARE(technique.graphicsApiFilter()->majorVersion(), cloneData.graphicsApiFilterData.m_major);
-            QCOMPARE(technique.graphicsApiFilter()->profile(), cloneData.graphicsApiFilterData.m_profile);
-            QCOMPARE(technique.graphicsApiFilter()->vendor(), cloneData.graphicsApiFilterData.m_vendor);
-            QCOMPARE(technique.graphicsApiFilter()->extensions(), cloneData.graphicsApiFilterData.m_extensions);
-            QCOMPARE(technique.graphicsApiFilter()->api(), cloneData.graphicsApiFilterData.m_api);
-            QCOMPARE(technique.id(), creationChangeData->subjectId());
-            QCOMPARE(technique.isEnabled(), false);
-            QCOMPARE(technique.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(technique.metaObject(), creationChangeData->metaObject());
-            QCOMPARE(technique.renderPasses().size(), cloneData.renderPassIds.size());
-            QCOMPARE(technique.parameters().size(), cloneData.parameterIds.size());
-            QCOMPARE(technique.filterKeys().size(), cloneData.filterKeyIds.size());
-            QCOMPARE(pass.id(), cloneData.renderPassIds.first());
-            QCOMPARE(parameter.id(), cloneData.parameterIds.first());
-            QCOMPARE(filterKey.id(), cloneData.filterKeyIds.first());
-        }
-    }
-
     void checkRenderPassUpdate()
     {
         // GIVEN
@@ -326,11 +245,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
         {
             // WHEN
@@ -338,9 +256,8 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
         }
     }
 
@@ -358,11 +275,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -371,11 +287,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 
@@ -393,11 +308,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -406,11 +320,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 
@@ -427,11 +340,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
         {
             // WHEN
@@ -439,11 +351,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
         {
             // WHEN
@@ -451,11 +362,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
         {
             // WHEN
@@ -463,11 +373,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QVERIFY(arbiter.dirtyNodes.contains(&technique));
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QVERIFY(arbiter.dirtyNodes().contains(&technique));
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
     }
 };
diff --git a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
index 37f0ba9a7..0e2c3ff2f 100644
--- a/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
+++ b/tests/auto/render/qtechniquefilter/tst_qtechniquefilter.cpp
@@ -30,14 +30,13 @@
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/qentity.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qtechniquefilter.h>
 #include <Qt3DRender/private/qtechniquefilter_p.h>
 #include <Qt3DRender/qparameter.h>
 #include <Qt3DRender/qfilterkey.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QTechniqueFilter: public QObject
 {
@@ -53,95 +52,6 @@ private Q_SLOTS:
         QCOMPARE(defaulttechniqueFilter->parameters().count(), 0);
     }
 
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QTechniqueFilter *>("techniqueFilter");
-        QTest::addColumn<QVector<Qt3DRender::QParameter *> >("parameters");
-        QTest::addColumn<QVector<Qt3DRender::QFilterKey *> >("filterKeys");
-
-        Qt3DRender::QTechniqueFilter *defaultConstructed = new Qt3DRender::QTechniqueFilter();
-        QTest::newRow("defaultConstructed") << defaultConstructed << QVector<Qt3DRender::QParameter *>() << QVector<Qt3DRender::QFilterKey *>();
-
-        Qt3DRender::QTechniqueFilter *techniqueFilterWithParams = new Qt3DRender::QTechniqueFilter();
-        Qt3DRender::QParameter *parameter1 = new Qt3DRender::QParameter(QStringLiteral("displacement"), 454.0f);
-        Qt3DRender::QParameter *parameter2 = new Qt3DRender::QParameter(QStringLiteral("torque"), 650);
-        QVector<Qt3DRender::QParameter *> params1 = QVector<Qt3DRender::QParameter *>() << parameter1 << parameter2;
-        techniqueFilterWithParams->addParameter(parameter1);
-        techniqueFilterWithParams->addParameter(parameter2);
-        QTest::newRow("techniqueFilterWithParams") << techniqueFilterWithParams << params1 << QVector<Qt3DRender::QFilterKey *>();
-
-        Qt3DRender::QTechniqueFilter *techniqueFilterWithAnnotations = new Qt3DRender::QTechniqueFilter();
-        Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
-        Qt3DRender::QFilterKey *filterKey2 = new Qt3DRender::QFilterKey();
-        filterKey1->setName(QStringLiteral("hasSuperCharger"));
-        filterKey1->setValue(true);
-        filterKey1->setName(QStringLiteral("hasNitroKit"));
-        filterKey1->setValue(false);
-        QVector<Qt3DRender::QFilterKey *> filterKeys1 = QVector<Qt3DRender::QFilterKey *>() << filterKey1 << filterKey2;
-        techniqueFilterWithAnnotations->addMatch(filterKey1);
-        techniqueFilterWithAnnotations->addMatch(filterKey2);
-        QTest::newRow("techniqueFilterWithAnnotations") << techniqueFilterWithAnnotations << QVector<Qt3DRender::QParameter *>() << filterKeys1;
-
-        Qt3DRender::QTechniqueFilter *techniqueFilterWithParamsAndAnnotations = new Qt3DRender::QTechniqueFilter();
-        Qt3DRender::QParameter *parameter3 = new Qt3DRender::QParameter(QStringLiteral("displacement"), 383.0f);
-        Qt3DRender::QParameter *parameter4 = new Qt3DRender::QParameter(QStringLiteral("torque"), 555);
-        Qt3DRender::QFilterKey *filterKey3 = new Qt3DRender::QFilterKey();
-        Qt3DRender::QFilterKey *filterKey4 = new Qt3DRender::QFilterKey();
-        filterKey3->setName(QStringLiteral("hasSuperCharger"));
-        filterKey3->setValue(false);
-        filterKey4->setName(QStringLiteral("hasNitroKit"));
-        filterKey4->setValue(true);
-        QVector<Qt3DRender::QParameter *> params2 = QVector<Qt3DRender::QParameter *>() << parameter3 << parameter4;
-        QVector<Qt3DRender::QFilterKey *> filterKeys2 = QVector<Qt3DRender::QFilterKey *>() << filterKey3 << filterKey4;
-        techniqueFilterWithParamsAndAnnotations->addParameter(parameter3);
-        techniqueFilterWithParamsAndAnnotations->addParameter(parameter4);
-        techniqueFilterWithParamsAndAnnotations->addMatch(filterKey3);
-        techniqueFilterWithParamsAndAnnotations->addMatch(filterKey4);
-        QTest::newRow("techniqueFilterWithParamsAndAnnotations") << techniqueFilterWithParamsAndAnnotations << params2 << filterKeys2;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QTechniqueFilter*, techniqueFilter);
-        QFETCH(QVector<Qt3DRender::QParameter *>, parameters);
-        QFETCH(QVector<Qt3DRender::QFilterKey *>, filterKeys);
-
-        // THEN
-        QCOMPARE(techniqueFilter->parameters(), parameters);
-        QCOMPARE(techniqueFilter->matchAll(), filterKeys);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(techniqueFilter);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1 + parameters.size() + filterKeys.size());
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QTechniqueFilterData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QTechniqueFilterData>>(creationChanges.first());
-        const Qt3DRender::QTechniqueFilterData &cloneData = creationChangeData->data;
-
-        QCOMPARE(techniqueFilter->id(), creationChangeData->subjectId());
-        QCOMPARE(techniqueFilter->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(techniqueFilter->metaObject(), creationChangeData->metaObject());
-
-        QCOMPARE(techniqueFilter->matchAll().count(), cloneData.matchIds.count());
-        QCOMPARE(techniqueFilter->parameters().count(), cloneData.parameterIds.count());
-
-        for (int i = 0, m = parameters.count(); i < m; ++i) {
-            Qt3DRender::QParameter *pOrig = parameters.at(i);
-            QCOMPARE(pOrig->id(), cloneData.parameterIds.at(i));
-        }
-
-        for (int i = 0, m = filterKeys.count(); i < m; ++i) {
-            Qt3DRender::QFilterKey *aOrig = filterKeys.at(i);
-            QCOMPARE(aOrig->id(), cloneData.matchIds.at(i));
-        }
-
-        delete techniqueFilter;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -155,10 +65,9 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
-        arbiter.dirtyNodes.clear();
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), techniqueFilter.data());
+        arbiter.clear();
 
 
         // WHEN
@@ -166,18 +75,16 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         techniqueFilter->removeParameter(param1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
-        arbiter.dirtyNodes.clear();
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), techniqueFilter.data());
+        arbiter.clear();
 
         // WHEN
         Qt3DRender::QFilterKey *filterKey1 = new Qt3DRender::QFilterKey();
@@ -185,28 +92,25 @@ private Q_SLOTS:
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
-        arbiter.dirtyNodes.clear();
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), techniqueFilter.data());
+        arbiter.clear();
 
         // WHEN
         techniqueFilter->addMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 0);
+        QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
         // WHEN
         techniqueFilter->removeMatch(filterKey1);
         QCoreApplication::processEvents();
 
         // THEN
-        QCOMPARE(arbiter.events.size(), 0);
-        QCOMPARE(arbiter.dirtyNodes.size(), 1);
-        QCOMPARE(arbiter.dirtyNodes.front(), techniqueFilter.data());
-        arbiter.dirtyNodes.clear();
+        QCOMPARE(arbiter.dirtyNodes().size(), 1);
+        QCOMPARE(arbiter.dirtyNodes().front(), techniqueFilter.data());
+        arbiter.clear();
     }
 
     void checkParameterBookkeeping()
diff --git a/tests/auto/render/qtextureimage/tst_qtextureimage.cpp b/tests/auto/render/qtextureimage/tst_qtextureimage.cpp
index ba5c2c3d8..9b2c75fb3 100644
--- a/tests/auto/render/qtextureimage/tst_qtextureimage.cpp
+++ b/tests/auto/render/qtextureimage/tst_qtextureimage.cpp
@@ -35,9 +35,7 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DRender/private/qtextureimage_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QTextureImage : public QObject
 {
@@ -101,68 +99,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QTextureImage textureImage;
-
-        textureImage.setSource(QUrl(QStringLiteral("URL")));
-        textureImage.setMirrored(false);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&textureImage);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureImageData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureImageData cloneData = creationChangeData->data;
-
-            QCOMPARE(textureImage.id(), creationChangeData->subjectId());
-            QCOMPARE(textureImage.isEnabled(), true);
-            QCOMPARE(textureImage.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(textureImage.metaObject(), creationChangeData->metaObject());
-
-            const auto generator = qSharedPointerCast<Qt3DRender::QImageTextureDataFunctor>(cloneData.generator);
-            QVERIFY(generator);
-            QCOMPARE(generator->isMirrored(), textureImage.isMirrored());
-            QCOMPARE(generator->url(), textureImage.source());
-
-        }
-
-        // WHEN
-        textureImage.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&textureImage);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureImageData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureImageData cloneData = creationChangeData->data;
-
-            QCOMPARE(textureImage.id(), creationChangeData->subjectId());
-            QCOMPARE(textureImage.isEnabled(), false);
-            QCOMPARE(textureImage.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(textureImage.metaObject(), creationChangeData->metaObject());
-
-            const auto generator = qSharedPointerCast<Qt3DRender::QImageTextureDataFunctor>(cloneData.generator);
-            QVERIFY(generator);
-            QCOMPARE(generator->isMirrored(), textureImage.isMirrored());
-            QCOMPARE(generator->url(), textureImage.source());
-        }
-    }
-
     void checkSourceUpdate()
     {
         // GIVEN
@@ -176,10 +112,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &textureImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &textureImage);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
         {
@@ -188,7 +124,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
@@ -206,10 +142,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &textureImage);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &textureImage);
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
 
         {
@@ -218,7 +154,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qtextureimagedata/tst_qtextureimagedata.cpp b/tests/auto/render/qtextureimagedata/tst_qtextureimagedata.cpp
index ba0c9a9bf..4912dac0c 100644
--- a/tests/auto/render/qtextureimagedata/tst_qtextureimagedata.cpp
+++ b/tests/auto/render/qtextureimagedata/tst_qtextureimagedata.cpp
@@ -31,7 +31,7 @@
 #include <Qt3DRender/private/qtextureimagedata_p.h>
 #include <Qt3DRender/qtextureimagedata.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 // We need to call QNode::clone which is protected
 // So we sublcass QNode instead of QObject
diff --git a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp
index b6d949c83..78c9a15a8 100644
--- a/tests/auto/render/qtextureloader/tst_qtextureloader.cpp
+++ b/tests/auto/render/qtextureloader/tst_qtextureloader.cpp
@@ -35,9 +35,7 @@ QT_WARNING_DISABLE_DEPRECATED
 #include <Qt3DRender/private/qtexture_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QTextureLoader : public QObject
 {
@@ -107,56 +105,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QTextureLoader textureLoader;
-
-        textureLoader.setSource(QUrl(QStringLiteral("SomeUrl")));
-        textureLoader.setMirrored(false);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&textureLoader);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-            const Qt3DRender::QAbstractTextureData cloneData = creationChangeData->data;
-
-            QCOMPARE(textureLoader.id(), creationChangeData->subjectId());
-            QCOMPARE(textureLoader.isEnabled(), true);
-            QCOMPARE(textureLoader.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(textureLoader.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        textureLoader.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&textureLoader);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QAbstractTextureData>>(creationChanges.first());
-
-            QCOMPARE(textureLoader.id(), creationChangeData->subjectId());
-            QCOMPARE(textureLoader.isEnabled(), false);
-            QCOMPARE(textureLoader.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(textureLoader.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkSourceUpdate()
     {
         // GIVEN
@@ -170,26 +118,16 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &textureLoader);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &textureLoader);
 
             Qt3DRender::QAbstractTexturePrivate *d = dynamic_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DRender::QAbstractTexturePrivate::get(&textureLoader));
             const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(d->dataFunctor());
             QVERIFY(generator);
             QCOMPARE(generator->url(), QUrl(QStringLiteral("Gary")));
 
-            arbiter.events.clear();
+            arbiter.clear();
         }
-
-        {
-            // WHEN
-            textureLoader.setSource(QUrl(QStringLiteral("Gary")));
-            QCoreApplication::processEvents();
-
-            // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-        }
-
     }
 
     void checkMirroredUpdate()
@@ -205,15 +143,15 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &textureLoader);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &textureLoader);
 
             Qt3DRender::QAbstractTexturePrivate *d = dynamic_cast<Qt3DRender::QAbstractTexturePrivate *>(Qt3DRender::QAbstractTexturePrivate::get(&textureLoader));
             const auto generator = qSharedPointerCast<Qt3DRender::QTextureFromSourceGenerator>(d->dataFunctor());
             QVERIFY(generator);
             QCOMPARE(generator->isMirrored(), false);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -222,7 +160,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
 
     }
diff --git a/tests/auto/render/qviewport/tst_qviewport.cpp b/tests/auto/render/qviewport/tst_qviewport.cpp
index ab3dda08f..287894c22 100644
--- a/tests/auto/render/qviewport/tst_qviewport.cpp
+++ b/tests/auto/render/qviewport/tst_qviewport.cpp
@@ -29,65 +29,17 @@
 #include <QtTest/QTest>
 #include <Qt3DCore/private/qnode_p.h>
 #include <Qt3DCore/private/qscene_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 
 #include <Qt3DRender/qviewport.h>
 #include <Qt3DRender/private/qviewport_p.h>
 
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QViewport: public QObject
 {
     Q_OBJECT
 
 private Q_SLOTS:
-
-    void checkCloning_data()
-    {
-        QTest::addColumn<Qt3DRender::QViewport *>("viewport");
-        QTest::addColumn<QRectF>("normalizedRect");
-        QTest::addColumn<float>("gamma");
-
-        Qt3DRender::QViewport *defaultConstructed = new Qt3DRender::QViewport();
-        QTest::newRow("defaultConstructed") << defaultConstructed << QRectF(0.0f, 0.0f, 1.0f, 1.0f) << 2.2f;
-
-        Qt3DRender::QViewport *smallGreenViewport = new Qt3DRender::QViewport();
-        smallGreenViewport->setNormalizedRect(QRectF(0.2f, 0.2f, 0.6f, 0.6f));
-        smallGreenViewport->setGamma(1.8f);
-        QTest::newRow("smallGreenViewport") << smallGreenViewport << QRectF(0.2f, 0.2f, 0.6f, 0.6f) << 1.8f;
-    }
-
-    void checkCloning()
-    {
-        // GIVEN
-        QFETCH(Qt3DRender::QViewport *, viewport);
-        QFETCH(QRectF, normalizedRect);
-        QFETCH(float, gamma);
-
-        // THEN
-        QCOMPARE(viewport->normalizedRect(), normalizedRect);
-        QCOMPARE(viewport->gamma(), gamma);
-
-        // WHEN
-        Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(viewport);
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges = creationChangeGenerator.creationChanges();
-
-        // THEN
-        QCOMPARE(creationChanges.size(), 1);
-
-        const Qt3DCore::QNodeCreatedChangePtr<Qt3DRender::QViewportData> creationChangeData =
-                qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QViewportData>>(creationChanges.first());
-        const Qt3DRender::QViewportData &cloneData = creationChangeData->data;
-
-        QCOMPARE(viewport->id(), creationChangeData->subjectId());
-        QCOMPARE(viewport->isEnabled(), creationChangeData->isNodeEnabled());
-        QCOMPARE(viewport->metaObject(), creationChangeData->metaObject());
-        QCOMPARE(viewport->normalizedRect(), cloneData.normalizedRect);
-        QCOMPARE(viewport->gamma(), cloneData.gamma);
-
-        delete viewport;
-    }
-
     void checkPropertyUpdates()
     {
         // GIVEN
@@ -101,31 +53,28 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), viewport.data());
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             viewport->setNormalizedRect(QRectF(0.5, 0.5, 1.0, 1.0));
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
             // WHEN
             viewport->setNormalizedRect(QRectF(0.0, 0.0, 1.0, 1.0));
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), viewport.data());
         }
 
-        arbiter.events.clear();
+        arbiter.clear();
 
         {
             // WHEN
@@ -133,28 +82,25 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), viewport.data());
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
 
             // WHEN
             viewport->setGamma(1.8f);
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
             // WHEN
             viewport->setGamma(2.0f);
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), viewport.data());
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), viewport.data());
         }
     }
 };
diff --git a/tests/auto/render/qwaitfence/tst_qwaitfence.cpp b/tests/auto/render/qwaitfence/tst_qwaitfence.cpp
index 801abfcc6..4c842c2cc 100644
--- a/tests/auto/render/qwaitfence/tst_qwaitfence.cpp
+++ b/tests/auto/render/qwaitfence/tst_qwaitfence.cpp
@@ -43,9 +43,7 @@
 #include <Qt3DRender/private/qwaitfence_p.h>
 #include <QObject>
 #include <QSignalSpy>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
-#include <Qt3DCore/qnodecreatedchange.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_QWaitFence : public QObject
 {
@@ -153,67 +151,6 @@ private Q_SLOTS:
         }
     }
 
-    void checkCreationData()
-    {
-        // GIVEN
-        Qt3DRender::QWaitFence waitFence;
-
-        waitFence.setHandleType(Qt3DRender::QWaitFence::OpenGLFenceId);
-        waitFence.setHandle(QVariant(1200));
-        waitFence.setWaitOnCPU(true);
-        waitFence.setTimeout(1584);
-
-        // WHEN
-        QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&waitFence);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QWaitFenceData>>(creationChanges.first());
-            const Qt3DRender::QWaitFenceData cloneData = creationChangeData->data;
-
-            QCOMPARE(waitFence.handleType(), cloneData.handleType);
-            QCOMPARE(waitFence.handle(), cloneData.handle);
-            QCOMPARE(waitFence.waitOnCPU(), cloneData.waitOnCPU);
-            QCOMPARE(waitFence.timeout(), cloneData.timeout);
-            QCOMPARE(waitFence.id(), creationChangeData->subjectId());
-            QCOMPARE(waitFence.isEnabled(), true);
-            QCOMPARE(waitFence.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(waitFence.metaObject(), creationChangeData->metaObject());
-        }
-
-        // WHEN
-        waitFence.setEnabled(false);
-
-        {
-            Qt3DCore::QNodeCreatedChangeGenerator creationChangeGenerator(&waitFence);
-            creationChanges = creationChangeGenerator.creationChanges();
-        }
-
-        // THEN
-        {
-            QCOMPARE(creationChanges.size(), 1);
-
-            const auto creationChangeData = qSharedPointerCast<Qt3DCore::QNodeCreatedChange<Qt3DRender::QWaitFenceData>>(creationChanges.first());
-            const Qt3DRender::QWaitFenceData cloneData = creationChangeData->data;
-
-            QCOMPARE(waitFence.handleType(), cloneData.handleType);
-            QCOMPARE(waitFence.handle(), cloneData.handle);
-            QCOMPARE(waitFence.waitOnCPU(), cloneData.waitOnCPU);
-            QCOMPARE(waitFence.timeout(), cloneData.timeout);
-            QCOMPARE(waitFence.id(), creationChangeData->subjectId());
-            QCOMPARE(waitFence.isEnabled(), false);
-            QCOMPARE(waitFence.isEnabled(), creationChangeData->isNodeEnabled());
-            QCOMPARE(waitFence.metaObject(), creationChangeData->metaObject());
-        }
-    }
-
     void checkHandleTypeUpdate()
     {
         // GIVEN
@@ -227,11 +164,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &waitFence);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -240,8 +176,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -258,11 +193,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &waitFence);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -271,8 +205,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -289,11 +222,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &waitFence);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -302,8 +234,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.events.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 
@@ -320,11 +251,10 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 1);
-            QCOMPARE(arbiter.dirtyNodes.front(), &waitFence);
+            QCOMPARE(arbiter.dirtyNodes().size(), 1);
+            QCOMPARE(arbiter.dirtyNodes().front(), &waitFence);
 
-            arbiter.dirtyNodes.clear();
+            arbiter.clear();
         }
 
         {
@@ -333,8 +263,7 @@ private Q_SLOTS:
             QCoreApplication::processEvents();
 
             // THEN
-            QCOMPARE(arbiter.events.size(), 0);
-            QCOMPARE(arbiter.dirtyNodes.size(), 0);
+            QCOMPARE(arbiter.dirtyNodes().size(), 0);
         }
     }
 };
diff --git a/tests/auto/render/raycaster/tst_raycaster.cpp b/tests/auto/render/raycaster/tst_raycaster.cpp
index 57a1bcf47..593852c65 100644
--- a/tests/auto/render/raycaster/tst_raycaster.cpp
+++ b/tests/auto/render/raycaster/tst_raycaster.cpp
@@ -32,7 +32,7 @@
 #include <Qt3DRender/qpickevent.h>
 #include <Qt3DRender/qraycaster.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 #include "testrenderer.h"
 
 class tst_RayCaster : public Qt3DCore::QBackendNodeTester
diff --git a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
index daec0b86c..c725bf73a 100644
--- a/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
+++ b/tests/auto/render/raycastingjob/tst_raycastingjob.cpp
@@ -27,12 +27,11 @@
 ****************************************************************************/
 
 #include "qmlscenereader.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 #include <QtTest/QTest>
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qtransform.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/private/qaspectjobmanager_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
 #include <Qt3DCore/private/qaspectmanager_p.h>
@@ -279,7 +278,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::RayCaster *backendRayCaster = test->nodeManagers()->rayCasterManager()->lookupResource(rayCaster->id());
         QVERIFY(backendRayCaster);
-        Qt3DCore::QBackendNodePrivate::get(backendRayCaster)->setArbiter(test->arbiter());
 
         // WHEN
         Qt3DRender::Render::RayCastingJob rayCastingJob;
@@ -339,7 +337,6 @@ private Q_SLOTS:
 
         Qt3DRender::Render::RayCaster *backendRayCaster = test->nodeManagers()->rayCasterManager()->lookupResource(rayCaster->id());
         QVERIFY(backendRayCaster);
-        Qt3DCore::QBackendNodePrivate::get(backendRayCaster)->setArbiter(test->arbiter());
 
         // WHEN
         Qt3DRender::Render::RayCastingJob rayCastingJob;
diff --git a/tests/auto/render/render.pro b/tests/auto/render/render.pro
index 14fc74883..e750407b3 100644
--- a/tests/auto/render/render.pro
+++ b/tests/auto/render/render.pro
@@ -133,7 +133,6 @@ qtConfig(qt3d-opengl-renderer):qtConfig(private_tests) {
             geometryloaders \
             picking \
             boundingsphere \
-            qdefaultmeshes \
             pickboundingvolumejob \
             gltfplugins \
             updatemeshtrianglelistjob \
diff --git a/tests/auto/render/rendercapture/tst_rendercapture.cpp b/tests/auto/render/rendercapture/tst_rendercapture.cpp
index 3ad3668c9..272d49e13 100644
--- a/tests/auto/render/rendercapture/tst_rendercapture.cpp
+++ b/tests/auto/render/rendercapture/tst_rendercapture.cpp
@@ -31,7 +31,7 @@
 #include <Qt3DRender/private/rendercapture_p.h>
 #include <Qt3DRender/qrendercapture.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 #include "testrenderer.h"
 
 class tst_RenderCapture : public Qt3DCore::QBackendNodeTester
diff --git a/tests/auto/render/scene2d/tst_scene2d.cpp b/tests/auto/render/scene2d/tst_scene2d.cpp
index b0a7fbeb8..4b4ba03f0 100644
--- a/tests/auto/render/scene2d/tst_scene2d.cpp
+++ b/tests/auto/render/scene2d/tst_scene2d.cpp
@@ -40,7 +40,6 @@
 #include <private/buffermanager_p.h>
 #include <Qt3DRender/qpicktriangleevent.h>
 #include <private/qpickevent_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <qbackendnodetester.h>
 #include "testrenderer.h"
 
diff --git a/tests/auto/render/sceneloader/tst_sceneloader.cpp b/tests/auto/render/sceneloader/tst_sceneloader.cpp
index d146abfcc..9efdd386c 100644
--- a/tests/auto/render/sceneloader/tst_sceneloader.cpp
+++ b/tests/auto/render/sceneloader/tst_sceneloader.cpp
@@ -31,11 +31,9 @@
 #include <Qt3DRender/qsceneloader.h>
 #include <Qt3DRender/private/scene_p.h>
 #include <Qt3DRender/private/scenemanager_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <Qt3DCore/private/qentity_p.h>
-#include <Qt3DCore/private/qpropertyupdatedchangebase_p.h>
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 #include "testrenderer.h"
 
 class tst_SceneLoader : public Qt3DCore::QBackendNodeTester
diff --git a/tests/auto/render/setfence/tst_setfence.cpp b/tests/auto/render/setfence/tst_setfence.cpp
index 75c414e7f..d7ef930ca 100644
--- a/tests/auto/render/setfence/tst_setfence.cpp
+++ b/tests/auto/render/setfence/tst_setfence.cpp
@@ -37,18 +37,13 @@
 **
 ****************************************************************************/
 
-// TODO Remove in Qt6
-#include <QtCore/qcompilerdetection.h>
-QT_WARNING_DISABLE_DEPRECATED
-
 #include <QtTest/QTest>
 #include <Qt3DRender/qsetfence.h>
 #include <Qt3DRender/private/qsetfence_p.h>
 #include <Qt3DRender/private/setfence_p.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include "qbackendnodetester.h"
 #include "testrenderer.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_SetFence : public Qt3DCore::QBackendNodeTester
 {
@@ -120,50 +115,6 @@ private Q_SLOTS:
             renderer.clearDirtyBits(Qt3DRender::Render::AbstractRenderer::AllDirty);
         }
     }
-
-    void checkSetHandleType()
-    {
-        // GIVEN
-        Qt3DRender::Render::SetFence backendSetFence;
-        TestRenderer renderer;
-        TestArbiter arbiter;
-
-        Qt3DCore::QBackendNodePrivate::get(&backendSetFence)->setArbiter(&arbiter);
-        backendSetFence.setRenderer(&renderer);
-
-        // WHEN
-        backendSetFence.setHandleType(Qt3DRender::QSetFence::OpenGLFenceId);
-
-        // THEN
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(arbiter.events.count(), 1);
-        QCOMPARE(change->propertyName(), "handleType");
-        QCOMPARE(change->value().value<Qt3DRender::QSetFence::HandleType>(), Qt3DRender::QSetFence::OpenGLFenceId);
-
-        arbiter.events.clear();
-    }
-
-    void checkSetHandle()
-    {
-        // GIVEN
-        Qt3DRender::Render::SetFence backendSetFence;
-        TestRenderer renderer;
-        TestArbiter arbiter;
-
-        Qt3DCore::QBackendNodePrivate::get(&backendSetFence)->setArbiter(&arbiter);
-        backendSetFence.setRenderer(&renderer);
-
-        // WHEN
-        backendSetFence.setHandle(QVariant(984));
-
-        // THEN
-        Qt3DCore::QPropertyUpdatedChangePtr change = arbiter.events.first().staticCast<Qt3DCore::QPropertyUpdatedChange>();
-        QCOMPARE(arbiter.events.count(), 1);
-        QCOMPARE(change->propertyName(), "handle");
-        QCOMPARE(change->value(), QVariant(984));
-
-        arbiter.events.clear();
-    }
 };
 
 QTEST_MAIN(tst_SetFence)
diff --git a/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp b/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp
index 24dbe514a..526f46243 100644
--- a/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp
+++ b/tests/auto/render/shaderbuilder/tst_shaderbuilder.cpp
@@ -28,13 +28,12 @@
 
 #include <QtTest/QTest>
 #include <qbackendnodetester.h>
-#include <Qt3DCore/qpropertyupdatedchange.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <Qt3DRender/private/shaderbuilder_p.h>
 #include <Qt3DRender/qshaderprogram.h>
 #include <Qt3DRender/qshaderprogrambuilder.h>
 #include "testrenderer.h"
-#include "testpostmanarbiter.h"
+#include <testarbiter.h>
 
 Q_DECLARE_METATYPE(Qt3DRender::QShaderProgram::ShaderType)
 
@@ -583,7 +582,6 @@ private slots:
 
         Qt3DRender::Render::ShaderBuilder backend;
         TestArbiter arbiter;
-        Qt3DCore::QBackendNodePrivate::get(&backend)->setArbiter(&arbiter);
 
 
         // WHEN
diff --git a/tests/auto/render/skeleton/tst_skeleton.cpp b/tests/auto/render/skeleton/tst_skeleton.cpp
index 63ed51058..f98d26694 100644
--- a/tests/auto/render/skeleton/tst_skeleton.cpp
+++ b/tests/auto/render/skeleton/tst_skeleton.cpp
@@ -36,7 +36,7 @@
 #include <Qt3DCore/private/qscene_p.h>
 #include <Qt3DCore/private/qbackendnode_p.h>
 #include <qbackendnodetester.h>
-#include <testpostmanarbiter.h>
+#include <testarbiter.h>
 #include <testrenderer.h>
 
 using namespace Qt3DCore;
diff --git a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
index 5552a1760..b6ee78f41 100644
--- a/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
+++ b/tests/auto/render/sortpolicy/tst_sortpolicy.cpp
@@ -55,7 +55,7 @@ private Q_SLOTS:
         Qt3DRender::QFrameGraphNode parent;
         auto parentBackend = new Qt3DRender::Render::FrameGraphNode;
         parentBackend->setRenderer(&renderer);
-        simulateInitialization(&parent, parentBackend);
+        simulateInitializationSync(&parent, parentBackend);
 
         Qt3DRender::Render::FrameGraphManager manager;
         manager.appendNode(parent.id(), parentBackend);
diff --git a/tests/auto/render/texture/tst_texture.cpp b/tests/auto/render/texture/tst_texture.cpp
index aec79bbbd..3db774eb4 100644
--- a/tests/auto/render/texture/tst_texture.cpp
+++ b/tests/auto/render/texture/tst_texture.cpp
@@ -30,8 +30,8 @@
 #include <qbackendnodetester.h>
 #include <Qt3DRender/private/texture_p.h>
 
-#include "testpostmanarbiter.h"
 #include "testrenderer.h"
+#include <testarbiter.h>
 
 class DummyTexture : public Qt3DRender::QAbstractTexture
 {
@@ -111,116 +111,104 @@ void tst_RenderTexture::checkFrontendPropertyNotifications()
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), &texture);
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 
     // WHEN
     texture.setWidth(512);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
     // WHEN
     texture.setHeight(256);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), &texture);
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 
     // WHEN
     texture.setHeight(256);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
     // WHEN
     texture.setDepth(128);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), &texture);
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 
     // WHEN
     texture.setDepth(128);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.events.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
     // WHEN
     texture.setLayers(16);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), &texture);
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 
     // WHEN
     texture.setLayers(16);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
     // WHEN
     texture.setSamples(32);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), &texture);
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 
     // WHEN
     texture.setSamples(32);
     QCoreApplication::processEvents();
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 0);
+    QCOMPARE(arbiter.dirtyNodes().size(), 0);
 
     // WHEN
     Qt3DRender::QTextureImage img;
     texture.addTextureImage(&img);
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), &texture);
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 
     // WHEN
     texture.removeTextureImage(&img);
 
     // THEN
-    QCOMPARE(arbiter.events.size(), 0);
-    QCOMPARE(arbiter.dirtyNodes.size(), 1);
-    QCOMPARE(arbiter.dirtyNodes.front(), &texture);
+    QCOMPARE(arbiter.dirtyNodes().size(), 1);
+    QCOMPARE(arbiter.dirtyNodes().front(), &texture);
 
-    arbiter.dirtyNodes.clear();
+    arbiter.clear();
 }
 
 template <typename FrontendTextureType, Qt3DRender::QAbstractTexture::Target Target>
diff --git a/tests/auto/render/transform/tst_transform.cpp b/tests/auto/render/transform/tst_transform.cpp
index a3fcdb9c8..b6c3c0b41 100644
--- a/tests/auto/render/transform/tst_transform.cpp
+++ b/tests/auto/render/transform/tst_transform.cpp
@@ -35,7 +35,7 @@
 #include <private/qbackendnode_p.h>
 #include "qbackendnodetester.h"
 #include "testrenderer.h"
-#include "testpostmanarbiter.h"
+#include "testarbiter.h"
 
 class tst_Transform : public Qt3DCore::QBackendNodeTester
 {
diff --git a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
index b2d0b612c..7e5a114bb 100644
--- a/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
+++ b/tests/auto/render/updateshaderdatatransformjob/tst_updateshaderdatatransformjob.cpp
@@ -37,7 +37,6 @@
 #include <Qt3DRender/qcamera.h>
 #include <Qt3DRender/private/shaderdata_p.h>
 #include <Qt3DRender/private/qrenderaspect_p.h>
-#include <Qt3DCore/private/qnodecreatedchangegenerator_p.h>
 #include <Qt3DCore/private/qnodevisitor_p.h>
 #include "qmlscenereader.h"