Remove deprecated classes and functions

Mostly old messaging API Change-Id: I17eb2206b2ede56d2f7d36375d5e711d6149019f Reviewed-by: Paul Lemire <paul.lemire@kdab.com>
author: Paul Lemire <paul.lemire@kdab.com> 2019-12-20 12:41:04 +0100
committer: Mike Krus <mike.krus@kdab.com> 2020-02-11 06:08:41 +0000
commit: b828609440a4771838c242b3ad9962ecd7a2fe99 (patch)
tree: 5da6bce0cda327c4cca96696bce512ec243cc1fd /tests/auto/core
parent: b0eb152b82cdd9658154ff7d9ef9e764eccc1ebd (diff)
19 files changed, 297 insertions, 2272 deletions
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);
     }
 };
author	Paul Lemire <paul.lemire@kdab.com>	2019-12-20 12:41:04 +0100
committer	Mike Krus <mike.krus@kdab.com>	2020-02-11 06:08:41 +0000
commit	b828609440a4771838c242b3ad9962ecd7a2fe99 (patch)
tree	5da6bce0cda327c4cca96696bce512ec243cc1fd /tests/auto/core
parent	b0eb152b82cdd9658154ff7d9ef9e764eccc1ebd (diff)