Move Qt3DCore into Qt3DCore namespace

Update other aspects, tests and examples accordingly.

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

18 files changed, 464 insertions, 464 deletions

diff --git a/tests/auto/core/arrayresourcesmanager/dynamicarraypolicy/tst_dynamicarraypolicy.cpp b/tests/auto/core/arrayresourcesmanager/dynamicarraypolicy/tst_dynamicarraypolicy.cpp
index cc2889eb6..5515fa6ad 100644
--- a/tests/auto/core/arrayresourcesmanager/dynamicarraypolicy/tst_dynamicarraypolicy.cpp
+++ b/tests/auto/core/arrayresourcesmanager/dynamicarraypolicy/tst_dynamicarraypolicy.cpp
@@ -69,16 +69,16 @@ public:
     QAtomicInt m_value;
 };
 
-typedef Qt3D::QHandle<tst_ArrayResource> tHandle;
-typedef Qt3D::QHandle<tst_ArrayResource, 4> tHandle4;
-typedef Qt3D::QHandle<tst_ArrayResource, 8> tHandle8;
-typedef Qt3D::QHandle<tst_ArrayResource, 16> tHandle16;
+typedef Qt3DCore::QHandle<tst_ArrayResource> tHandle;
+typedef Qt3DCore::QHandle<tst_ArrayResource, 4> tHandle4;
+typedef Qt3DCore::QHandle<tst_ArrayResource, 8> tHandle8;
+typedef Qt3DCore::QHandle<tst_ArrayResource, 16> tHandle16;
 
 void tst_DynamicArrayPolicy::createResourcesManager()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, int, 16> manager16;
-    Qt3D::QResourceManager<tst_ArrayResource, int, 4> manager4;
-    Qt3D::QResourceManager<tst_ArrayResource, int, 8> manager8;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 16> manager16;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 4> manager4;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 8> manager8;
     QVERIFY(manager16.maxResourcesEntries() == 65535);
     QVERIFY(manager8.maxResourcesEntries() == 255);
     QVERIFY(manager4.maxResourcesEntries() == 15);
@@ -90,7 +90,7 @@ void tst_DynamicArrayPolicy::createResourcesManager()
  */
 void tst_DynamicArrayPolicy::acquireResources()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 4> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 4> manager;
 
     QList<tHandle4> handles;
 
@@ -110,7 +110,7 @@ void tst_DynamicArrayPolicy::acquireResources()
 void tst_DynamicArrayPolicy::getResources()
 {
 
-    Qt3D::QResourceManager<tst_ArrayResource, int, 8> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 8> manager;
     QList<tst_ArrayResource *> resources;
     QList<tHandle8> handles;
 
@@ -141,7 +141,7 @@ void tst_DynamicArrayPolicy::getResources()
  */
 void tst_DynamicArrayPolicy::registerResourcesResize()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 16> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 16> manager;
     QList<tHandle16> handles;
 
     for (uint i = 0; i < 2; i++) {
@@ -169,7 +169,7 @@ void tst_DynamicArrayPolicy::registerResourcesResize()
  */
 void tst_DynamicArrayPolicy::removeResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, int> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle> handles;
@@ -193,7 +193,7 @@ void tst_DynamicArrayPolicy::removeResource()
  */
 void tst_DynamicArrayPolicy::resetResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle16> handles;
@@ -220,7 +220,7 @@ void tst_DynamicArrayPolicy::resetResource()
 
 void tst_DynamicArrayPolicy::lookupResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle16> handles;
@@ -245,7 +245,7 @@ void tst_DynamicArrayPolicy::lookupResource()
 
 void tst_DynamicArrayPolicy::releaseResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint> manager;
     QList<tst_ArrayResource *> resources;
 
     for (int i = 0; i < 5; i++) {
@@ -267,11 +267,11 @@ class tst_Thread : public QThread
     Q_OBJECT
 public:
 
-    typedef Qt3D::QResourceManager<tst_ArrayResource,
+    typedef Qt3DCore::QResourceManager<tst_ArrayResource,
     int,
     16,
-    Qt3D::ArrayAllocatingPolicy,
-    Qt3D::ObjectLevelLockingPolicy> Manager;
+    Qt3DCore::ArrayAllocatingPolicy,
+    Qt3DCore::ObjectLevelLockingPolicy> Manager;
 
     tst_Thread()
         : QThread()
@@ -338,11 +338,11 @@ class tst_Thread2 : public QThread
     Q_OBJECT
 public:
 
-    typedef Qt3D::QResourceManager<tst_ArrayResource,
+    typedef Qt3DCore::QResourceManager<tst_ArrayResource,
     int,
     16,
-    Qt3D::ArrayAllocatingPolicy,
-    Qt3D::ObjectLevelLockingPolicy> Manager;
+    Qt3DCore::ArrayAllocatingPolicy,
+    Qt3DCore::ObjectLevelLockingPolicy> Manager;
 
     tst_Thread2(int releaseAbove = 7)
         : QThread()
@@ -414,7 +414,7 @@ void tst_DynamicArrayPolicy::heavyDutyMultiThreadedAccessRelease()
 
 void tst_DynamicArrayPolicy::maximumNumberOfResources()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle16> handles;
diff --git a/tests/auto/core/arrayresourcesmanager/preallocatedarraypolicy/tst_preallocatedarraypolicy.cpp b/tests/auto/core/arrayresourcesmanager/preallocatedarraypolicy/tst_preallocatedarraypolicy.cpp
index c3fa5aea5..d56196d00 100644
--- a/tests/auto/core/arrayresourcesmanager/preallocatedarraypolicy/tst_preallocatedarraypolicy.cpp
+++ b/tests/auto/core/arrayresourcesmanager/preallocatedarraypolicy/tst_preallocatedarraypolicy.cpp
@@ -69,16 +69,16 @@ public:
     QAtomicInt m_value;
 };
 
-typedef Qt3D::QHandle<tst_ArrayResource> tHandle;
-typedef Qt3D::QHandle<tst_ArrayResource, 4> tHandle4;
-typedef Qt3D::QHandle<tst_ArrayResource, 8> tHandle8;
-typedef Qt3D::QHandle<tst_ArrayResource, 16> tHandle16;
+typedef Qt3DCore::QHandle<tst_ArrayResource> tHandle;
+typedef Qt3DCore::QHandle<tst_ArrayResource, 4> tHandle4;
+typedef Qt3DCore::QHandle<tst_ArrayResource, 8> tHandle8;
+typedef Qt3DCore::QHandle<tst_ArrayResource, 16> tHandle16;
 
 void tst_PreallocatedArrayPolicy::createResourcesManager()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, int, 16, Qt3D::ArrayPreallocationPolicy> manager16;
-    Qt3D::QResourceManager<tst_ArrayResource, int, 4, Qt3D::ArrayPreallocationPolicy> manager4;
-    Qt3D::QResourceManager<tst_ArrayResource, int, 8, Qt3D::ArrayPreallocationPolicy> manager8;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 16, Qt3DCore::ArrayPreallocationPolicy> manager16;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 4, Qt3DCore::ArrayPreallocationPolicy> manager4;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 8, Qt3DCore::ArrayPreallocationPolicy> manager8;
     QVERIFY(manager16.maxResourcesEntries() == 65535);
     QVERIFY(manager8.maxResourcesEntries() == 255);
     QVERIFY(manager4.maxResourcesEntries() == 15);
@@ -90,7 +90,7 @@ void tst_PreallocatedArrayPolicy::createResourcesManager()
  */
 void tst_PreallocatedArrayPolicy::acquireResources()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 4, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 4, Qt3DCore::ArrayPreallocationPolicy> manager;
 
     QList<tHandle4> handles;
 
@@ -110,7 +110,7 @@ void tst_PreallocatedArrayPolicy::acquireResources()
 void tst_PreallocatedArrayPolicy::getResources()
 {
 
-    Qt3D::QResourceManager<tst_ArrayResource, int, 8, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 8, Qt3DCore::ArrayPreallocationPolicy> manager;
     QList<tst_ArrayResource *> resources;
     QList<tHandle8> handles;
 
@@ -141,7 +141,7 @@ void tst_PreallocatedArrayPolicy::getResources()
  */
 void tst_PreallocatedArrayPolicy::registerResourcesResize()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 16, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 16, Qt3DCore::ArrayPreallocationPolicy> manager;
     QList<tHandle16> handles;
 
     for (uint i = 0; i < 2; i++) {
@@ -169,7 +169,7 @@ void tst_PreallocatedArrayPolicy::registerResourcesResize()
  */
 void tst_PreallocatedArrayPolicy::removeResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, int, 16, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, int, 16, Qt3DCore::ArrayPreallocationPolicy> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle> handles;
@@ -193,7 +193,7 @@ void tst_PreallocatedArrayPolicy::removeResource()
  */
 void tst_PreallocatedArrayPolicy::resetResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 16, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 16, Qt3DCore::ArrayPreallocationPolicy> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle16> handles;
@@ -220,7 +220,7 @@ void tst_PreallocatedArrayPolicy::resetResource()
 
 void tst_PreallocatedArrayPolicy::lookupResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 16, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 16, Qt3DCore::ArrayPreallocationPolicy> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle16> handles;
@@ -245,7 +245,7 @@ void tst_PreallocatedArrayPolicy::lookupResource()
 
 void tst_PreallocatedArrayPolicy::releaseResource()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 16, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 16, Qt3DCore::ArrayPreallocationPolicy> manager;
     QList<tst_ArrayResource *> resources;
 
     for (int i = 0; i < 5; i++) {
@@ -267,11 +267,11 @@ class tst_Thread : public QThread
     Q_OBJECT
 public:
 
-    typedef Qt3D::QResourceManager<tst_ArrayResource,
+    typedef Qt3DCore::QResourceManager<tst_ArrayResource,
     int,
     16,
-    Qt3D::ArrayPreallocationPolicy,
-    Qt3D::ObjectLevelLockingPolicy> Manager;
+    Qt3DCore::ArrayPreallocationPolicy,
+    Qt3DCore::ObjectLevelLockingPolicy> Manager;
 
     tst_Thread()
         : QThread()
@@ -339,11 +339,11 @@ class tst_Thread2 : public QThread
     Q_OBJECT
 public:
 
-    typedef Qt3D::QResourceManager<tst_ArrayResource,
+    typedef Qt3DCore::QResourceManager<tst_ArrayResource,
     int,
     16,
-    Qt3D::ArrayPreallocationPolicy,
-    Qt3D::ObjectLevelLockingPolicy> Manager;
+    Qt3DCore::ArrayPreallocationPolicy,
+    Qt3DCore::ObjectLevelLockingPolicy> Manager;
 
     tst_Thread2(int releaseAbove = 7)
         : QThread()
@@ -415,7 +415,7 @@ void tst_PreallocatedArrayPolicy::heavyDutyMultiThreadedAccessRelease()
 
 void tst_PreallocatedArrayPolicy::maximumNumberOfResources()
 {
-    Qt3D::QResourceManager<tst_ArrayResource, uint, 16, Qt3D::ArrayPreallocationPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ArrayResource, uint, 16, Qt3DCore::ArrayPreallocationPolicy> manager;
 
     QList<tst_ArrayResource *> resources;
     QList<tHandle16> handles;
diff --git a/tests/auto/core/cloning/tst_cloning.cpp b/tests/auto/core/cloning/tst_cloning.cpp
index 1ea911698..1ddada245 100644
--- a/tests/auto/core/cloning/tst_cloning.cpp
+++ b/tests/auto/core/cloning/tst_cloning.cpp
@@ -51,11 +51,11 @@ private slots:
     void checkEntityCloning();
 };
 
-class MyQNode : public Qt3D::QNode
+class MyQNode : public Qt3DCore::QNode
 {
     Q_OBJECT
 public:
-    explicit MyQNode(Qt3D::QNode *parent = 0) : QNode(parent)
+    explicit MyQNode(Qt3DCore::QNode *parent = 0) : QNode(parent)
     {}
 
     ~MyQNode()
@@ -75,19 +75,19 @@ public:
     }
 
 protected:
-    void copy(const Qt3D::QNode *ref) Q_DECL_OVERRIDE
+    void copy(const Qt3DCore::QNode *ref) Q_DECL_OVERRIDE
     {
-        Qt3D::QNode::copy(ref);
+        Qt3DCore::QNode::copy(ref);
         const MyQNode *refNode = qobject_cast<const MyQNode *>(ref);
         setCustomProperty(refNode->customProperty());
     }
 };
 
-class MyQComponent : public Qt3D::QComponent
+class MyQComponent : public Qt3DCore::QComponent
 {
     Q_OBJECT
 public:
-    explicit MyQComponent(Qt3D::QNode *parent = 0) : QComponent(parent)
+    explicit MyQComponent(Qt3DCore::QNode *parent = 0) : QComponent(parent)
     {}
 
     ~MyQComponent()
@@ -101,11 +101,11 @@ public:
 void tst_Cloning::checkEntityCloning()
 {
     // GIVEN
-    Qt3D::QScene *scene = new Qt3D::QScene();
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene();
     MyQNode *root = new MyQNode();
-    Qt3D::QNodePrivate::get(root)->setScene(scene);
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene);
 
-    Qt3D::QEntity *entity = new Qt3D::QEntity(root);
+    Qt3DCore::QEntity *entity = new Qt3DCore::QEntity(root);
 
     // WHEN
     MyQComponent *comp1 = new MyQComponent();
@@ -133,16 +133,16 @@ void tst_Cloning::checkEntityCloning()
     QCOMPARE(cloneRoot->id(), root->id());
     QVERIFY(cloneRoot->customProperty() == root->customProperty());
 
-    Qt3D::QEntity *cloneEntity = qobject_cast<Qt3D::QEntity *>(cloneRoot->children().first());
+    Qt3DCore::QEntity *cloneEntity = qobject_cast<Qt3DCore::QEntity *>(cloneRoot->children().first());
     QVERIFY(cloneEntity != Q_NULLPTR);
     QCOMPARE(cloneEntity->id(), entity->id());
     QCOMPARE(cloneEntity->children().count(), 4);
     QCOMPARE(cloneEntity->components().count(), 3);
 
-    QList<Qt3D::QNodeId> ids = QList<Qt3D::QNodeId>() << comp1->id() << comp2->id() << comp3->id() << childNode->id();
+    QList<Qt3DCore::QNodeId> ids = QList<Qt3DCore::QNodeId>() << comp1->id() << comp2->id() << comp3->id() << childNode->id();
 
     Q_FOREACH (QObject *c, cloneEntity->children()) {
-        Qt3D::QNode *n = qobject_cast<Qt3D::QNode *>(c);
+        Qt3DCore::QNode *n = qobject_cast<Qt3DCore::QNode *>(c);
         QVERIFY(ids.contains(n->id()));
         ids.removeAll(n->id());
     }
diff --git a/tests/auto/core/handle/tst_handle.cpp b/tests/auto/core/handle/tst_handle.cpp
index 7f2c01903..d993056a1 100644
--- a/tests/auto/core/handle/tst_handle.cpp
+++ b/tests/auto/core/handle/tst_handle.cpp
@@ -69,8 +69,8 @@ public:
     int m_value;
 };
 
-typedef Qt3D::QHandle<SimpleResource> Handle;
-typedef Qt3D::QHandle<SimpleResource, 22> BigHandle;
+typedef Qt3DCore::QHandle<SimpleResource> Handle;
+typedef Qt3DCore::QHandle<SimpleResource, 22> BigHandle;
 
 void tst_Handle::defaultConstruction()
 {
diff --git a/tests/auto/core/handlemanager/tst_handlemanager.cpp b/tests/auto/core/handlemanager/tst_handlemanager.cpp
index bdbc6252a..66911f2c9 100644
--- a/tests/auto/core/handlemanager/tst_handlemanager.cpp
+++ b/tests/auto/core/handlemanager/tst_handlemanager.cpp
@@ -67,17 +67,17 @@ public:
     int m_value;
 };
 
-typedef Qt3D::QHandle<SimpleResource> Handle;
+typedef Qt3DCore::QHandle<SimpleResource> Handle;
 
 void tst_HandleManager::construction()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     QVERIFY(manager.activeEntries() == 0);
 }
 
 void tst_HandleManager::correctPointer()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     SimpleResource *p1 = (SimpleResource *)0xdeadbeef;
     const Handle h = manager.acquire(p1);
 
@@ -89,7 +89,7 @@ void tst_HandleManager::correctPointer()
 
 void tst_HandleManager::correctPointers()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     SimpleResource *p[3];
     p[0] = (SimpleResource *)0xdeadbeef;
     p[1] = (SimpleResource *)0x11111111;
@@ -109,7 +109,7 @@ void tst_HandleManager::correctPointers()
 
 void tst_HandleManager::correctConstPointer()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     QSharedPointer<SimpleResource> p1(new SimpleResource);
     const Handle h = manager.acquire(p1.data());
 
@@ -121,7 +121,7 @@ void tst_HandleManager::correctConstPointer()
 
 void tst_HandleManager::nullForRemovedEntry()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     QSharedPointer<SimpleResource> p1(new SimpleResource);
     const Handle h = manager.acquire(p1.data());
     manager.release(h);
@@ -134,7 +134,7 @@ void tst_HandleManager::nullForRemovedEntry()
 
 void tst_HandleManager::validHandleForReplacementEntry()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     QSharedPointer<SimpleResource> p1(new SimpleResource);
     const Handle h = manager.acquire(p1.data());
     QVERIFY(manager.activeEntries() == 1);
@@ -155,7 +155,7 @@ void tst_HandleManager::validHandleForReplacementEntry()
 
 void tst_HandleManager::updateChangesValue()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     QSharedPointer<SimpleResource> p1(new SimpleResource);
     const Handle h = manager.acquire(p1.data());
 
@@ -171,7 +171,7 @@ void tst_HandleManager::updateChangesValue()
 
 void tst_HandleManager::resetRemovesAllEntries()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
     for (int i = 0; i < 100; ++i) {
         SimpleResource *p = (SimpleResource *) 0xdead0000 + i;
         const Handle h = manager.acquire(p);
@@ -190,7 +190,7 @@ void tst_HandleManager::resetRemovesAllEntries()
 
 void tst_HandleManager::maximumEntries()
 {
-    Qt3D::QHandleManager<SimpleResource> manager;
+    Qt3DCore::QHandleManager<SimpleResource> manager;
 
     QCOMPARE(Handle::maxIndex(), (uint)((1 << 16) - 1));
 
diff --git a/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp b/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp
index 3f18fee4b..a3dbb3ea1 100644
--- a/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp
+++ b/tests/auto/core/listresourcesmanager/tst_listresourcesmanager.cpp
@@ -69,16 +69,16 @@ public:
     QAtomicInt m_value;
 };
 
-typedef Qt3D::QHandle<tst_ListResource> tHandle;
-typedef Qt3D::QHandle<tst_ListResource, 4> tHandle4;
-typedef Qt3D::QHandle<tst_ListResource, 8> tHandle8;
-typedef Qt3D::QHandle<tst_ListResource, 16> tHandle16;
+typedef Qt3DCore::QHandle<tst_ListResource> tHandle;
+typedef Qt3DCore::QHandle<tst_ListResource, 4> tHandle4;
+typedef Qt3DCore::QHandle<tst_ListResource, 8> tHandle8;
+typedef Qt3DCore::QHandle<tst_ListResource, 16> tHandle16;
 
 void tst_ListResourcesManager::createResourcesManager()
 {
-    Qt3D::QResourceManager<tst_ListResource, int, 16, Qt3D::ListAllocatingPolicy> manager16;
-    Qt3D::QResourceManager<tst_ListResource, int, 4, Qt3D::ListAllocatingPolicy> manager4;
-    Qt3D::QResourceManager<tst_ListResource, int, 8, Qt3D::ListAllocatingPolicy> manager8;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 16, Qt3DCore::ListAllocatingPolicy> manager16;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 4, Qt3DCore::ListAllocatingPolicy> manager4;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 8, Qt3DCore::ListAllocatingPolicy> manager8;
 
     QVERIFY(manager16.maxResourcesEntries() == 65535);
     QVERIFY(manager8.maxResourcesEntries() == 255);
@@ -91,7 +91,7 @@ void tst_ListResourcesManager::createResourcesManager()
  */
 void tst_ListResourcesManager::acquireResources()
 {
-    Qt3D::QResourceManager<tst_ListResource, int, 4, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 4, Qt3DCore::ListAllocatingPolicy> manager;
 
     QList<tHandle4> handles;
 
@@ -111,7 +111,7 @@ void tst_ListResourcesManager::acquireResources()
 void tst_ListResourcesManager::getResources()
 {
 
-    Qt3D::QResourceManager<tst_ListResource, int, 8, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 8, Qt3DCore::ListAllocatingPolicy> manager;
     QList<tst_ListResource *> resources;
     QList<tHandle8> handles;
 
@@ -142,7 +142,7 @@ void tst_ListResourcesManager::getResources()
  */
 void tst_ListResourcesManager::registerResourcesResize()
 {
-    Qt3D::QResourceManager<tst_ListResource, int, 16, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 16, Qt3DCore::ListAllocatingPolicy> manager;
     QList<tHandle16> handles;
 
     for (uint i = 0; i < 2; i++) {
@@ -170,7 +170,7 @@ void tst_ListResourcesManager::registerResourcesResize()
  */
 void tst_ListResourcesManager::removeResource()
 {
-    Qt3D::QResourceManager<tst_ListResource, int, 16, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 16, Qt3DCore::ListAllocatingPolicy> manager;
 
     QList<tst_ListResource *> resources;
     QList<tHandle> handles;
@@ -194,7 +194,7 @@ void tst_ListResourcesManager::removeResource()
  */
 void tst_ListResourcesManager::resetResource()
 {
-    Qt3D::QResourceManager<tst_ListResource, int, 16, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, int, 16, Qt3DCore::ListAllocatingPolicy> manager;
 
     QList<tst_ListResource *> resources;
     QList<tHandle16> handles;
@@ -221,7 +221,7 @@ void tst_ListResourcesManager::resetResource()
 
 void tst_ListResourcesManager::lookupResource()
 {
-    Qt3D::QResourceManager<tst_ListResource, uint, 16, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, uint, 16, Qt3DCore::ListAllocatingPolicy> manager;
 
     QList<tst_ListResource *> resources;
     QList<tHandle16> handles;
@@ -246,7 +246,7 @@ void tst_ListResourcesManager::lookupResource()
 
 void tst_ListResourcesManager::releaseResource()
 {
-    Qt3D::QResourceManager<tst_ListResource, uint, 16, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, uint, 16, Qt3DCore::ListAllocatingPolicy> manager;
     QList<tst_ListResource *> resources;
 
     for (int i = 0; i < 5; i++) {
@@ -268,11 +268,11 @@ class tst_Thread : public QThread
     Q_OBJECT
 public:
 
-    typedef Qt3D::QResourceManager<tst_ListResource,
+    typedef Qt3DCore::QResourceManager<tst_ListResource,
                             int,
                             16,
-                            Qt3D::ListAllocatingPolicy,
-                            Qt3D::ObjectLevelLockingPolicy> Manager;
+                            Qt3DCore::ListAllocatingPolicy,
+                            Qt3DCore::ObjectLevelLockingPolicy> Manager;
 
     tst_Thread() : QThread()
     {
@@ -339,11 +339,11 @@ class tst_Thread2 : public QThread
     Q_OBJECT
 public:
 
-    typedef Qt3D::QResourceManager<tst_ListResource,
+    typedef Qt3DCore::QResourceManager<tst_ListResource,
                             int,
                             16,
-                            Qt3D::ListAllocatingPolicy,
-                            Qt3D::ObjectLevelLockingPolicy> Manager;
+                            Qt3DCore::ListAllocatingPolicy,
+                            Qt3DCore::ObjectLevelLockingPolicy> Manager;
 
     tst_Thread2(int releaseAbove = 7)
         : QThread()
@@ -415,7 +415,7 @@ void tst_ListResourcesManager::heavyDutyMultiThreadedAccessRelease()
 
 void tst_ListResourcesManager::maximumNumberOfResources()
 {
-    Qt3D::QResourceManager<tst_ListResource, uint, 16, Qt3D::ListAllocatingPolicy> manager;
+    Qt3DCore::QResourceManager<tst_ListResource, uint, 16, Qt3DCore::ListAllocatingPolicy> manager;
 
     QList<tst_ListResource *> resources;
     QList<tHandle16> handles;
diff --git a/tests/auto/core/nodes/tst_nodes.cpp b/tests/auto/core/nodes/tst_nodes.cpp
index 41ddcad43..629c03365 100644
--- a/tests/auto/core/nodes/tst_nodes.cpp
+++ b/tests/auto/core/nodes/tst_nodes.cpp
@@ -84,87 +84,87 @@ private slots:
 };
 
 class ObserverSpy;
-class SimplePostman : public Qt3D::QAbstractPostman
+class SimplePostman : public Qt3DCore::QAbstractPostman
 {
 public:
     SimplePostman(ObserverSpy *spy)
         : m_spy(spy)
     {}
 
-    void sceneChangeEvent(const Qt3D::QSceneChangePtr &) Q_DECL_FINAL {};
-    void setScene(Qt3D::QScene *) Q_DECL_FINAL {};
-    void notifyBackend(const Qt3D::QSceneChangePtr &change) Q_DECL_FINAL;
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) Q_DECL_FINAL {};
+    void setScene(Qt3DCore::QScene *) Q_DECL_FINAL {};
+    void notifyBackend(const Qt3DCore::QSceneChangePtr &change) Q_DECL_FINAL;
 
 private:
     ObserverSpy *m_spy;
 };
 
-class ObserverSpy : public Qt3D::QAbstractArbiter
+class ObserverSpy : public Qt3DCore::QAbstractArbiter
 {
 public:
-    class ChangeRecord : public QPair<Qt3D::QSceneChangePtr, bool>
+    class ChangeRecord : public QPair<Qt3DCore::QSceneChangePtr, bool>
     {
     public:
-        ChangeRecord(const Qt3D::QSceneChangePtr &event, bool locked)
-            : QPair<Qt3D::QSceneChangePtr, bool>(event, locked)
+        ChangeRecord(const Qt3DCore::QSceneChangePtr &event, bool locked)
+            : QPair<Qt3DCore::QSceneChangePtr, bool>(event, locked)
         {}
 
-        Qt3D::QSceneChangePtr change() const { return first; }
+        Qt3DCore::QSceneChangePtr change() const { return first; }
 
         bool wasLocked() const { return second; }
     };
 
-    ObserverSpy(Qt3D::QNode *node)
-        : Qt3D::QAbstractArbiter()
+    ObserverSpy(Qt3DCore::QNode *node)
+        : Qt3DCore::QAbstractArbiter()
         , m_node(node)
         , m_postman(new SimplePostman(this))
     {
-        Qt3D::QNodePrivate::get(node)->setArbiter(this);
+        Qt3DCore::QNodePrivate::get(node)->setArbiter(this);
     }
 
     ~ObserverSpy()
     {
-        Qt3D::QNodePrivate::get(m_node)->setArbiter(Q_NULLPTR);
+        Qt3DCore::QNodePrivate::get(m_node)->setArbiter(Q_NULLPTR);
     }
 
-    void sceneChangeEventWithLock(const Qt3D::QSceneChangePtr &e) Q_DECL_OVERRIDE
+    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE
     {
         events << ChangeRecord(e, true);
     }
 
-    void sceneChangeEventWithLock(const Qt3D::QSceneChangeList &e) Q_DECL_OVERRIDE
+    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &e) Q_DECL_OVERRIDE
     {
         for (uint i = 0, m = e.size(); i < m; ++i) {
             events << ChangeRecord(e.at(i), false);
         }
     }
 
-    void sceneChangeEvent(const Qt3D::QSceneChangePtr &e) Q_DECL_OVERRIDE
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE
     {
         events << ChangeRecord(e, false);
     }
 
-    Qt3D::QAbstractPostman *postman() const Q_DECL_FINAL
+    Qt3DCore::QAbstractPostman *postman() const Q_DECL_FINAL
     {
         return m_postman.data();
     }
 
     QList<ChangeRecord> events;
-    Qt3D::QNode *m_node;
+    Qt3DCore::QNode *m_node;
     QScopedPointer<SimplePostman> m_postman;
 };
 
-void SimplePostman::notifyBackend(const Qt3D::QSceneChangePtr &change)
+void SimplePostman::notifyBackend(const Qt3DCore::QSceneChangePtr &change)
 {
     m_spy->sceneChangeEventWithLock(change);
 }
 
-class MyQNode : public Qt3D::QNode
+class MyQNode : public Qt3DCore::QNode
 {
     Q_OBJECT
     Q_PROPERTY(QString customProperty READ customProperty WRITE setCustomProperty NOTIFY customPropertyChanged)
 public:
-    explicit MyQNode(Qt3D::QNode *parent = 0)
+    explicit MyQNode(Qt3DCore::QNode *parent = 0)
         : QNode(parent)
         , m_scene(Q_NULLPTR)
     {}
@@ -192,8 +192,8 @@ public:
     void assignScene()
     {
         if (!m_scene)
-            m_scene = new Qt3D::QScene();
-        Qt3D::QNodePrivate::get(this)->setScene(m_scene);
+            m_scene = new Qt3DCore::QScene();
+        Qt3DCore::QNodePrivate::get(this)->setScene(m_scene);
     }
 
     void makeCopyOf(QNode *other)
@@ -208,14 +208,14 @@ protected:
     QT3D_CLONEABLE(MyQNode)
 
     QString m_customProperty;
-    Qt3D::QScene *m_scene;
+    Qt3DCore::QScene *m_scene;
 };
 
-class MyQComponent : public Qt3D::QComponent
+class MyQComponent : public Qt3DCore::QComponent
 {
     Q_OBJECT
 public:
-    explicit MyQComponent(Qt3D::QNode *parent = 0) : QComponent(parent)
+    explicit MyQComponent(Qt3DCore::QNode *parent = 0) : QComponent(parent)
     {}
 
     ~MyQComponent()
@@ -261,8 +261,8 @@ void tst_Nodes::defaultComponentConstruction()
 void tst_Nodes::defaultEntityConstrution()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new Qt3D::QEntity());
-    Qt3D::QEntity *entity2 = new Qt3D::QEntity(entity.data());
+    QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity());
+    Qt3DCore::QEntity *entity2 = new Qt3DCore::QEntity(entity.data());
 
     // THEN
     QVERIFY(entity->components().isEmpty());
@@ -278,7 +278,7 @@ void tst_Nodes::appendSingleChildNodeToNodeNoSceneExplicitParenting()
     ObserverSpy spy(node.data());
 
     // THEN
-    QVERIFY(Qt3D::QNodePrivate::get(node.data())->scene() == Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() == Q_NULLPTR);
     // WHEN
     QScopedPointer<MyQNode> child(new MyQNode());
 
@@ -305,7 +305,7 @@ void tst_Nodes::appendSingleChildNodeToNodeNoSceneImplicitParenting()
     ObserverSpy spy(node.data());
 
     // THEN
-    QVERIFY(Qt3D::QNodePrivate::get(node.data())->scene() == Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() == Q_NULLPTR);
     // WHEN
     QScopedPointer<MyQNode> child(new MyQNode(node.data()));
 
@@ -326,11 +326,11 @@ void tst_Nodes::appendMultipleChildNodesToNodeNoScene()
     ObserverSpy spy(node.data());
 
     // THEN
-    QVERIFY(Qt3D::QNodePrivate::get(node.data())->scene() == Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() == Q_NULLPTR);
     // WHEN
     for (int i = 0; i < 10; i++) {
         // WHEN
-        Qt3D::QNode *child = Q_NULLPTR;
+        Qt3DCore::QNode *child = Q_NULLPTR;
         if (i % 2 == 0) {
             child = new MyQNode(node.data());
         } else {
@@ -357,7 +357,7 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneExplicitParenting()
     // WHEN
     node->assignScene();
     // THEN
-    QVERIFY(Qt3D::QNodePrivate::get(node.data())->scene() != Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() != Q_NULLPTR);
 
     // WHEN
     QScopedPointer<MyQNode> child(new MyQNode());
@@ -376,10 +376,10 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneExplicitParenting()
     QVERIFY(spy.events.first().wasLocked());
     QCOMPARE(node->children().count(), 1);
 
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::NodeCreated);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::NodeCreated);
     QCOMPARE(event->propertyName(), "node");
-    Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+    Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), child->id());
     QCOMPARE(clone->parentNode()->id(), node->id());
 }
@@ -393,7 +393,7 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneImplicitParenting()
     // WHEN
     node->assignScene();
     // THEN
-    QVERIFY(Qt3D::QNodePrivate::get(node.data())->scene() != Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() != Q_NULLPTR);
 
     // WHEN
     QScopedPointer<MyQNode> child(new MyQNode(node.data()));
@@ -402,16 +402,16 @@ void tst_Nodes::appendSingleChildNodeToNodeSceneImplicitParenting()
     // THEN
     QVERIFY(child->parent() == node.data());
     QVERIFY(child->parentNode() == node.data());
-    QVERIFY(Qt3D::QNodePrivate::get(child.data())->scene() != Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(child.data())->scene() != Q_NULLPTR);
 
     QCOMPARE(spy.events.size(), 1);
     QVERIFY(spy.events.first().wasLocked());
     QCOMPARE(node->children().count(), 1);
 
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::NodeCreated);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::NodeCreated);
     QCOMPARE(event->propertyName(), "node");
-    Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+    Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), child->id());
     QCOMPARE(clone->parentNode()->id(), node->id());
 }
@@ -426,12 +426,12 @@ void tst_Nodes::appendMultipleChildNodesToNodeScene()
     node->assignScene();
     ObserverSpy spy(node.data());
     // THEN
-    QVERIFY(Qt3D::QNodePrivate::get(node.data())->scene() != Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(node.data())->scene() != Q_NULLPTR);
 
     // WHEN
     for (int i = 0; i < 10; i++) {
         // WHEN
-        Qt3D::QNode *child = Q_NULLPTR;
+        Qt3DCore::QNode *child = Q_NULLPTR;
         if (i % 2 == 0) {
             child = new MyQNode(node.data());
             QCoreApplication::processEvents();
@@ -442,7 +442,7 @@ void tst_Nodes::appendMultipleChildNodesToNodeScene()
         }
         // THEN
         QVERIFY(child->parent() == node.data());
-        QVERIFY(Qt3D::QNodePrivate::get(child)->scene() != Q_NULLPTR);
+        QVERIFY(Qt3DCore::QNodePrivate::get(child)->scene() != Q_NULLPTR);
     }
     // THEN
     QCOMPARE(node->children().count(), 10);
@@ -452,14 +452,14 @@ void tst_Nodes::appendMultipleChildNodesToNodeScene()
     Q_FOREACH (const ObserverSpy::ChangeRecord &r, spy.events) {
 
         QVERIFY(r.wasLocked());
-        Qt3D::QScenePropertyChangePtr event = r.change().dynamicCast<Qt3D::QScenePropertyChange>();
-        QCOMPARE(event->type(), Qt3D::NodeCreated);
+        Qt3DCore::QScenePropertyChangePtr event = r.change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+        QCOMPARE(event->type(), Qt3DCore::NodeCreated);
         QCOMPARE(event->propertyName(), "node");
-        Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+        Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
 
         bool found = false;
         Q_FOREACH (QObject *c, node->children()) {
-            if (clone->id() == qobject_cast<Qt3D::QNode *>(c)->id()) {
+            if (clone->id() == qobject_cast<Qt3DCore::QNode *>(c)->id()) {
                 found = true;
                 QCOMPARE(clone->parentNode()->id(), node->id());
                 break;
@@ -477,7 +477,7 @@ void tst_Nodes::checkParentChangeToNull()
 
     // WHEN
     root->assignScene();
-    QScopedPointer<Qt3D::QNode> child(new MyQNode(root.data()));
+    QScopedPointer<Qt3DCore::QNode> child(new MyQNode(root.data()));
     QCoreApplication::processEvents();
 
     // THEN
@@ -495,10 +495,10 @@ void tst_Nodes::checkParentChangeToNull()
     QCOMPARE(spy.events.size(), 1);
 
     QVERIFY(spy.events.first().wasLocked());
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::NodeAboutToBeDeleted);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::NodeAboutToBeDeleted);
     QCOMPARE(event->propertyName(), "node");
-    Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+    Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), child->id());
     QVERIFY(!clone->parentNode());
 }
@@ -519,14 +519,14 @@ void tst_Nodes::checkParentChangeToOtherParent()
     // WHEN
     ObserverSpy spyParent1(parent1.data());
     ObserverSpy spyParent2(parent2.data());
-    QScopedPointer<Qt3D::QNode> child(new MyQNode(parent1.data()));
+    QScopedPointer<Qt3DCore::QNode> child(new MyQNode(parent1.data()));
     QCoreApplication::processEvents();
 
     // THEN
     QVERIFY(child->parent() == parent1.data());
     QCOMPARE(parent1->children().size(), 1);
     QCOMPARE(parent2->children().size(), 0);
-    QVERIFY(Qt3D::QNodePrivate::get(child.data())->scene() != Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(child.data())->scene() != Q_NULLPTR);
     QCOMPARE(spyParent1.events.size(), 1);
 
     // WHEN
@@ -542,19 +542,19 @@ void tst_Nodes::checkParentChangeToOtherParent()
 
     // CHECK event 1 is  a Node Deleted event
     QVERIFY(spyParent1.events.first().wasLocked());
-    Qt3D::QScenePropertyChangePtr event = spyParent1.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::NodeAboutToBeDeleted);
+    Qt3DCore::QScenePropertyChangePtr event = spyParent1.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::NodeAboutToBeDeleted);
     QCOMPARE(event->propertyName(), "node");
-    Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+    Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), child->id());
     QVERIFY(!clone->parentNode());
 
     // CHECK event 2 is a Node Added event
     QVERIFY(spyParent2.events.last().wasLocked());
-    event = spyParent2.events.last().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::NodeCreated);
+    event = spyParent2.events.last().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::NodeCreated);
     QCOMPARE(event->propertyName(), "node");
-    clone = event->value().value<Qt3D::QNodePtr>();
+    clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), child->id());
     QVERIFY(clone->parentNode());
 }
@@ -564,7 +564,7 @@ void tst_Nodes::removingSingleChildNodeFromNode()
 {
     // GIVEN
     QScopedPointer<MyQNode> root(new MyQNode());
-    QScopedPointer<Qt3D::QNode> child(new MyQNode());
+    QScopedPointer<Qt3DCore::QNode> child(new MyQNode());
 
     // WHEN
     child->setParent(root.data());
@@ -583,10 +583,10 @@ void tst_Nodes::removingSingleChildNodeFromNode()
 
     QCOMPARE(spy.events.size(), 1);
     QVERIFY(spy.events.first().wasLocked());
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::NodeAboutToBeDeleted);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::NodeAboutToBeDeleted);
     QCOMPARE(event->propertyName(), "node");
-    Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+    Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), child->id());
     QVERIFY(!clone->parentNode());
 }
@@ -601,7 +601,7 @@ void tst_Nodes::removingMultipleChildNodesFromNode()
     ObserverSpy spy(root.data());
 
     // THEN
-    QVERIFY(Qt3D::QNodePrivate::get(root.data())->scene() != Q_NULLPTR);
+    QVERIFY(Qt3DCore::QNodePrivate::get(root.data())->scene() != Q_NULLPTR);
 
     // WHEN
     for (int i = 0; i < 10; i++)
@@ -623,10 +623,10 @@ void tst_Nodes::removingMultipleChildNodesFromNode()
     QCOMPARE(spy.events.size(), 10);
     Q_FOREACH (const ObserverSpy::ChangeRecord &r, spy.events) {
         QVERIFY(r.wasLocked());
-        Qt3D::QScenePropertyChangePtr event = r.change().dynamicCast<Qt3D::QScenePropertyChange>();
-        QCOMPARE(event->type(), Qt3D::NodeAboutToBeDeleted);
+        Qt3DCore::QScenePropertyChangePtr event = r.change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+        QCOMPARE(event->type(), Qt3DCore::NodeAboutToBeDeleted);
         QCOMPARE(event->propertyName(), "node");
-        Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+        Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
         QVERIFY(!clone->parentNode());
     }
 }
@@ -637,7 +637,7 @@ void tst_Nodes::appendingChildEntitiesToNode()
     QScopedPointer<MyQNode> root(new MyQNode());
 
     // WHEN
-    Qt3D::QEntity *childEntity = new Qt3D::QEntity(root.data());
+    Qt3DCore::QEntity *childEntity = new Qt3DCore::QEntity(root.data());
 
     // THEN
     QVERIFY(root->children().first() == childEntity);
@@ -651,7 +651,7 @@ void tst_Nodes::removingChildEntitiesFromNode()
     QScopedPointer<MyQNode> root(new MyQNode());
 
     // WHEN
-    Qt3D::QEntity *childEntity = new Qt3D::QEntity(root.data());
+    Qt3DCore::QEntity *childEntity = new Qt3DCore::QEntity(root.data());
 
     // THEN
     QVERIFY(root->children().first() == childEntity);
@@ -670,7 +670,7 @@ void tst_Nodes::removingChildEntitiesFromNode()
 void tst_Nodes::appendingParentlessComponentToEntity()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new Qt3D::QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity());
     MyQComponent *comp = new MyQComponent();
 
     // THEN
@@ -697,10 +697,10 @@ void tst_Nodes::appendingParentlessComponentToEntity()
     // return early in such a case.
 
     // Check that we received ComponentAdded
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::ComponentAdded);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::ComponentAdded);
     QCOMPARE(event->propertyName(), "component");
-    Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+    Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), comp->id());
     QVERIFY(!clone->parentNode());
 }
@@ -708,7 +708,7 @@ void tst_Nodes::appendingParentlessComponentToEntity()
 void tst_Nodes::appendingComponentToEntity()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new Qt3D::QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity());
     MyQComponent *comp = new MyQComponent(entity.data());
     QCoreApplication::processEvents();
 
@@ -728,10 +728,10 @@ void tst_Nodes::appendingComponentToEntity()
     QVERIFY(comp->parentNode() == entity.data());
     QCOMPARE(spy.events.size(), 1);
     QVERIFY(spy.events.first().wasLocked());
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::ComponentAdded);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::ComponentAdded);
     QCOMPARE(event->propertyName(), "component");
-    Qt3D::QNodePtr clone = event->value().value<Qt3D::QNodePtr>();
+    Qt3DCore::QNodePtr clone = event->value().value<Qt3DCore::QNodePtr>();
     QCOMPARE(clone->id(), comp->id());
     QVERIFY(!clone->parentNode());
 }
@@ -739,7 +739,7 @@ void tst_Nodes::appendingComponentToEntity()
 void tst_Nodes::removingComponentFromEntity()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new Qt3D::QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity(new Qt3DCore::QEntity());
     MyQComponent *comp = new MyQComponent();
 
     // WHEN
@@ -760,10 +760,10 @@ void tst_Nodes::removingComponentFromEntity()
     QVERIFY(entity->children().count() == 1);
     QCOMPARE(spy.events.size(), 1);
     QVERIFY(spy.events.first().wasLocked());
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::ComponentRemoved);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::ComponentRemoved);
     QCOMPARE(event->propertyName(), "componentId");
-    Qt3D::QNodeId nodeId = event->value().value<Qt3D::QNodeId>();
+    Qt3DCore::QNodeId nodeId = event->value().value<Qt3DCore::QNodeId>();
     QCOMPARE(nodeId, comp->id());
 }
 
@@ -777,8 +777,8 @@ void tst_Nodes::changeCustomProperty()
     // THEN
     QCOMPARE(spy.events.size(), 1);
     QVERIFY(spy.events.first().wasLocked());
-    Qt3D::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3D::QScenePropertyChange>();
-    QCOMPARE(event->type(), Qt3D::NodeUpdated);
+    Qt3DCore::QScenePropertyChangePtr event = spy.events.takeFirst().change().dynamicCast<Qt3DCore::QScenePropertyChange>();
+    QCOMPARE(event->type(), Qt3DCore::NodeUpdated);
     QCOMPARE(event->propertyName(), "customProperty");
     QCOMPARE(event->value().toString(), QString("foo"));
 }
@@ -787,7 +787,7 @@ void tst_Nodes::checkDestruction()
 {
     // GIVEN
     QScopedPointer<MyQNode> root(new MyQNode());
-    Qt3D::QEntity *entity = new Qt3D::QEntity(root.data());
+    Qt3DCore::QEntity *entity = new Qt3DCore::QEntity(root.data());
 
     MyQComponent *comp1 = new MyQComponent();
     MyQComponent *comp2 = new MyQComponent();
diff --git a/tests/auto/core/qaspectengine/tst_qaspectengine.cpp b/tests/auto/core/qaspectengine/tst_qaspectengine.cpp
index 0f6a30c8e..69b7a916e 100644
--- a/tests/auto/core/qaspectengine/tst_qaspectengine.cpp
+++ b/tests/auto/core/qaspectengine/tst_qaspectengine.cpp
@@ -39,7 +39,7 @@
 #include <Qt3DCore/qentity.h>
 #include <Qt3DCore/qtransform.h>
 
-using namespace Qt3D;
+using namespace Qt3DCore;
 
 class tst_QAspectEngine : public QObject
 {
@@ -85,7 +85,7 @@ void tst_QAspectEngine::shouldNotCrashOnShutdownWhenComponentIsCreatedWithParent
     // GIVEN
     QEntity *root = new QEntity;
     // A component parented to an entity...
-    QComponent *component = new Qt3D::QTransform(root);
+    QComponent *component = new Qt3DCore::QTransform(root);
     // ... created *before* the entity it will be added to.
     QEntity *entity = new QEntity(root);
     entity->addComponent(component);
diff --git a/tests/auto/core/qaspectfactory/tst_qaspectfactory.cpp b/tests/auto/core/qaspectfactory/tst_qaspectfactory.cpp
index d52821d42..6da0489e3 100644
--- a/tests/auto/core/qaspectfactory/tst_qaspectfactory.cpp
+++ b/tests/auto/core/qaspectfactory/tst_qaspectfactory.cpp
@@ -38,7 +38,7 @@
 #include <Qt3DCore/QAspectFactory>
 #include <Qt3DCore/QAbstractAspect>
 
-using namespace QT_PREPEND_NAMESPACE(Qt3D);
+using namespace QT_PREPEND_NAMESPACE(Qt3DCore);
 
 #define FAKE_ASPECT(ClassName) \
 class ClassName : public QAbstractAspect \
diff --git a/tests/auto/core/qboundedcircularbuffer/tst_qboundedcircularbuffer.cpp b/tests/auto/core/qboundedcircularbuffer/tst_qboundedcircularbuffer.cpp
index 2a61cee97..ce4489f4b 100644
--- a/tests/auto/core/qboundedcircularbuffer/tst_qboundedcircularbuffer.cpp
+++ b/tests/auto/core/qboundedcircularbuffer/tst_qboundedcircularbuffer.cpp
@@ -39,7 +39,7 @@
 
 #include <Qt3DCore/private/qboundedcircularbuffer_p.h>
 
-using namespace Qt3D;
+using namespace Qt3DCore;
 
 class tst_QBoundedCircularBuffer : public QObject
 {
diff --git a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
index fd3d622cd..0382ecae6 100644
--- a/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
+++ b/tests/auto/core/qchangearbiter/tst_qchangearbiter.cpp
@@ -64,75 +64,75 @@ private slots:
     void distributeBackendChanges();
 };
 
-class tst_Node : public Qt3D::QNode
+class tst_Node : public Qt3DCore::QNode
 {
 public:
-    explicit tst_Node(Qt3D::QNode *parent = 0) : Qt3D::QNode(parent)
+    explicit tst_Node(Qt3DCore::QNode *parent = 0) : Qt3DCore::QNode(parent)
     {}
 
     void sendNodeAddedNotification()
     {
-        Qt3D::QScenePropertyChangePtr e(new Qt3D::QScenePropertyChange(Qt3D::NodeAdded, Qt3D::QSceneChange::Node, id()));
+        Qt3DCore::QScenePropertyChangePtr e(new Qt3DCore::QScenePropertyChange(Qt3DCore::NodeAdded, Qt3DCore::QSceneChange::Node, id()));
         e->setPropertyName("NodeAdded");
-        Qt3D::QNodePrivate::get(this)->notifyObservers(e);
+        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
     }
 
     void sendNodeRemovedNotification()
     {
-        Qt3D::QScenePropertyChangePtr e(new Qt3D::QScenePropertyChange(Qt3D::NodeRemoved, Qt3D::QSceneChange::Node, id()));
+        Qt3DCore::QScenePropertyChangePtr e(new Qt3DCore::QScenePropertyChange(Qt3DCore::NodeRemoved, Qt3DCore::QSceneChange::Node, id()));
         e->setPropertyName("NodeRemoved");
-        Qt3D::QNodePrivate::get(this)->notifyObservers(e);
+        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
     }
 
     void sendNodeUpdatedNotification()
     {
-        Qt3D::QScenePropertyChangePtr e(new Qt3D::QScenePropertyChange(Qt3D::NodeUpdated, Qt3D::QSceneChange::Node, id()));
+        Qt3DCore::QScenePropertyChangePtr e(new Qt3DCore::QScenePropertyChange(Qt3DCore::NodeUpdated, Qt3DCore::QSceneChange::Node, id()));
         e->setPropertyName("NodeUpdated");
-        Qt3D::QNodePrivate::get(this)->notifyObservers(e);
+        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
     }
 
     void sendComponentAddedNotification()
     {
-        Qt3D::QScenePropertyChangePtr e(new Qt3D::QScenePropertyChange(Qt3D::ComponentAdded, Qt3D::QSceneChange::Node, id()));
+        Qt3DCore::QScenePropertyChangePtr e(new Qt3DCore::QScenePropertyChange(Qt3DCore::ComponentAdded, Qt3DCore::QSceneChange::Node, id()));
         e->setPropertyName("ComponentAdded");
-        Qt3D::QNodePrivate::get(this)->notifyObservers(e);
+        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
     }
 
     void sendComponentRemovedNotification()
     {
-        Qt3D::QScenePropertyChangePtr e(new Qt3D::QScenePropertyChange(Qt3D::ComponentRemoved, Qt3D::QSceneChange::Node, id()));
+        Qt3DCore::QScenePropertyChangePtr e(new Qt3DCore::QScenePropertyChange(Qt3DCore::ComponentRemoved, Qt3DCore::QSceneChange::Node, id()));
         e->setPropertyName("ComponentRemoved");
-        Qt3D::QNodePrivate::get(this)->notifyObservers(e);
+        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
     }
 
     void sendAllChangesNotification()
     {
-        Qt3D::QScenePropertyChangePtr e(new Qt3D::QScenePropertyChange(Qt3D::AllChanges, Qt3D::QSceneChange::Node, id()));
+        Qt3DCore::QScenePropertyChangePtr e(new Qt3DCore::QScenePropertyChange(Qt3DCore::AllChanges, Qt3DCore::QSceneChange::Node, id()));
         e->setPropertyName("AllChanges");
-        Qt3D::QNodePrivate::get(this)->notifyObservers(e);
+        Qt3DCore::QNodePrivate::get(this)->notifyObservers(e);
     }
 
-    void sceneChangeEvent(const Qt3D::QSceneChangePtr &change) Q_DECL_OVERRIDE
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &change) Q_DECL_OVERRIDE
     {
         QVERIFY(!change.isNull());
         m_lastChanges << change;
     }
 
-    Qt3D::QSceneChangePtr lastChange() const
+    Qt3DCore::QSceneChangePtr lastChange() const
     {
         if (m_lastChanges.isEmpty())
-            return Qt3D::QSceneChangePtr();
+            return Qt3DCore::QSceneChangePtr();
         return m_lastChanges.last();
     }
 
-    QList<Qt3D::QSceneChangePtr> lastChanges() const
+    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
     {
         return m_lastChanges;
     }
 
     // QNode interface
 protected:
-    Qt3D::QNode *doClone() const
+    Qt3DCore::QNode *doClone() const
     {
         tst_Node *clone = new tst_Node();
         clone->copy(this);
@@ -140,54 +140,54 @@ protected:
     }
 
 private:
-    QList<Qt3D::QSceneChangePtr> m_lastChanges;
+    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
 };
 
-class tst_SimpleObserver : public Qt3D::QObserverInterface
+class tst_SimpleObserver : public Qt3DCore::QObserverInterface
 {
 public:
 
     // QObserverInterface interface
-    void sceneChangeEvent(const Qt3D::QSceneChangePtr &e) Q_DECL_OVERRIDE
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE
     {
         QVERIFY(!e.isNull());
         m_lastChanges.append(e);
     }
 
-    Qt3D::QSceneChangePtr lastChange() const
+    Qt3DCore::QSceneChangePtr lastChange() const
     {
         if (m_lastChanges.isEmpty())
-            return Qt3D::QSceneChangePtr();
+            return Qt3DCore::QSceneChangePtr();
         return m_lastChanges.last();
     }
 
-    QList<Qt3D::QSceneChangePtr> lastChanges() const
+    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
     {
         return m_lastChanges;
     }
 
 private:
-    QList<Qt3D::QSceneChangePtr> m_lastChanges;
+    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
 };
 
-class tst_BackendObserverObservable : public Qt3D::QBackendNode
+class tst_BackendObserverObservable : public Qt3DCore::QBackendNode
 {
 public:
 
     tst_BackendObserverObservable()
-        : Qt3D::QBackendNode(ReadWrite)
+        : Qt3DCore::QBackendNode(ReadWrite)
     {}
 
-    void updateFromPeer(Qt3D::QNode *) Q_DECL_OVERRIDE
+    void updateFromPeer(Qt3DCore::QNode *) Q_DECL_OVERRIDE
     {}
 
     // QObserverInterface interface
-    void sceneChangeEvent(const Qt3D::QSceneChangePtr &e) Q_DECL_OVERRIDE
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e) Q_DECL_OVERRIDE
     {
         QVERIFY(!e.isNull());
         m_lastChanges << e;
         // Save reply to be sent to the frontend
-        m_reply.reset(new Qt3D::QBackendScenePropertyChange(Qt3D::NodeUpdated, e->subjectId()));
+        m_reply.reset(new Qt3DCore::QBackendScenePropertyChange(Qt3DCore::NodeUpdated, e->subjectId()));
         m_reply->setTargetNode(e->subjectId());
         m_reply->setPropertyName("Reply");
     }
@@ -200,21 +200,21 @@ public:
         qDebug() << Q_FUNC_INFO;
     }
 
-    Qt3D::QSceneChangePtr lastChange() const
+    Qt3DCore::QSceneChangePtr lastChange() const
     {
         if (m_lastChanges.isEmpty())
-            return Qt3D::QSceneChangePtr();
+            return Qt3DCore::QSceneChangePtr();
         return m_lastChanges.last();
     }
 
-    QList<Qt3D::QSceneChangePtr> lastChanges() const
+    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
     {
         return m_lastChanges;
     }
 
 private:
-    QList<Qt3D::QSceneChangePtr> m_lastChanges;
-    Qt3D::QBackendScenePropertyChangePtr m_reply;
+    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
+    Qt3DCore::QBackendScenePropertyChangePtr m_reply;
 
 };
 
@@ -224,7 +224,7 @@ class ThreadedAnswer : public QThread
 {
     Q_OBJECT
 public:
-    ThreadedAnswer(Qt3D::QChangeArbiter *arbiter, tst_BackendObserverObservable *backend)
+    ThreadedAnswer(Qt3DCore::QChangeArbiter *arbiter, tst_BackendObserverObservable *backend)
         : QThread()
         , m_arbiter(arbiter)
         , m_backendObs(backend)
@@ -233,7 +233,7 @@ public:
     void run() Q_DECL_OVERRIDE
     {
         // create backend change queue on QChangeArbiter
-        Qt3D::QChangeArbiter::createThreadLocalChangeQueue(m_arbiter);
+        Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(m_arbiter);
         m_backendObs->sendReply();
         // gives time for other threads to start waiting
         QThread::currentThread()->sleep(1);
@@ -243,105 +243,105 @@ public:
     }
 
 private:
-    Qt3D::QChangeArbiter *m_arbiter;
+    Qt3DCore::QChangeArbiter *m_arbiter;
     tst_BackendObserverObservable *m_backendObs;
     QWaitCondition m_waitingForReplyToBeSent;
 };
 
-class tst_PostManObserver : public Qt3D::QAbstractPostman
+class tst_PostManObserver : public Qt3DCore::QAbstractPostman
 {
 public:
 
     tst_PostManObserver() : m_sceneInterface(Q_NULLPTR)
     {}
 
-    void setScene(Qt3D::QScene *scene) Q_DECL_FINAL
+    void setScene(Qt3DCore::QScene *scene) Q_DECL_FINAL
     {
         m_sceneInterface = scene;
     }
 
     // QObserverInterface interface
-    void sceneChangeEvent(const Qt3D::QSceneChangePtr &e)
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &e)
     {
         QVERIFY(!e.isNull());
-        Qt3D::QBackendScenePropertyChangePtr change = qSharedPointerDynamicCast<Qt3D::QBackendScenePropertyChange>(e);
+        Qt3DCore::QBackendScenePropertyChangePtr change = qSharedPointerDynamicCast<Qt3DCore::QBackendScenePropertyChange>(e);
         QVERIFY(!change.isNull());
-        Qt3D::QNode *targetNode = m_sceneInterface->lookupNode(change->targetNode());
+        Qt3DCore::QNode *targetNode = m_sceneInterface->lookupNode(change->targetNode());
         QVERIFY(targetNode != Q_NULLPTR);
         m_lastChanges << e;
     }
 
-    Qt3D::QSceneChangePtr lastChange() const
+    Qt3DCore::QSceneChangePtr lastChange() const
     {
         if (m_lastChanges.isEmpty())
-            return Qt3D::QSceneChangePtr();
+            return Qt3DCore::QSceneChangePtr();
         return m_lastChanges.last();
     }
 
-    QList<Qt3D::QSceneChangePtr> lastChanges() const
+    QList<Qt3DCore::QSceneChangePtr> lastChanges() const
     {
         return m_lastChanges;
     }
 
-    void notifyBackend(const Qt3D::QSceneChangePtr &e) Q_DECL_FINAL
+    void notifyBackend(const Qt3DCore::QSceneChangePtr &e) Q_DECL_FINAL
     {
         m_sceneInterface->arbiter()->sceneChangeEventWithLock(e);
     }
 
 private:
-    Qt3D::QScene *m_sceneInterface;
-    QList<Qt3D::QSceneChangePtr> m_lastChanges;
+    Qt3DCore::QScene *m_sceneInterface;
+    QList<Qt3DCore::QSceneChangePtr> m_lastChanges;
 };
 
-class tst_SceneObserver : public Qt3D::QSceneObserverInterface
+class tst_SceneObserver : public Qt3DCore::QSceneObserverInterface
 {
     // QSceneObserverInterface interface
 public:
-    void sceneNodeAdded(Qt3D::QSceneChangePtr &e)
+    void sceneNodeAdded(Qt3DCore::QSceneChangePtr &e)
     {
         QVERIFY(!e.isNull());
-        QVERIFY(e->type() == Qt3D::NodeCreated);
+        QVERIFY(e->type() == Qt3DCore::NodeCreated);
         m_lastChange = e;
     }
 
-    void sceneNodeRemoved(Qt3D::QSceneChangePtr &e)
+    void sceneNodeRemoved(Qt3DCore::QSceneChangePtr &e)
     {
         QVERIFY(!e.isNull());
-        QVERIFY((e->type() == Qt3D::NodeDeleted || e->type() == Qt3D::NodeAboutToBeDeleted));
+        QVERIFY((e->type() == Qt3DCore::NodeDeleted || e->type() == Qt3DCore::NodeAboutToBeDeleted));
         m_lastChange = e;
     }
 
-    void sceneNodeUpdated(Qt3D::QSceneChangePtr &e)
+    void sceneNodeUpdated(Qt3DCore::QSceneChangePtr &e)
     {
         m_lastChange = e;
     }
 
-    Qt3D::QSceneChangePtr lastChange() const
+    Qt3DCore::QSceneChangePtr lastChange() const
     {
         return m_lastChange;
     }
 
 private:
-    Qt3D::QSceneChangePtr m_lastChange;
+    Qt3DCore::QSceneChangePtr m_lastChange;
 };
 
 void tst_QChangeArbiter::registerObservers()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QChangeArbiter> arbiter(new Qt3D::QChangeArbiter());
-    QScopedPointer<Qt3D::QScene> scene(new Qt3D::QScene());
-    QScopedPointer<Qt3D::QAbstractPostman> postman(new tst_PostManObserver);
+    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
-    Qt3D::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
 
     // WHEN
-    Qt3D::QNode *root = new tst_Node();
-    Qt3D::QNode *child = new tst_Node();
-    Qt3D::QNodePrivate::get(root)->setScene(scene.data());
+    Qt3DCore::QNode *root = new tst_Node();
+    Qt3DCore::QNode *child = new tst_Node();
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
     scene->addObservable(root);
 
     QList<tst_SimpleObserver *> observers;
@@ -361,29 +361,29 @@ void tst_QChangeArbiter::registerObservers()
     arbiter->syncChanges();
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::NodeCreated);
     }
 
-    Qt3D::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
 
 void tst_QChangeArbiter::registerSceneObserver()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QChangeArbiter> arbiter(new Qt3D::QChangeArbiter());
-    QScopedPointer<Qt3D::QScene> scene(new Qt3D::QScene());
-    QScopedPointer<Qt3D::QAbstractPostman> postman(new tst_PostManObserver);
+    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
-    Qt3D::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
 
     // WHEN
     tst_Node *root = new tst_Node();
-    Qt3D::QNode *child = new tst_Node();
-    Qt3D::QNodePrivate::get(root)->setScene(scene.data());
+    Qt3DCore::QNode *child = new tst_Node();
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
     scene->addObservable(root);
 
     QList<tst_SimpleObserver *> observers;
@@ -415,11 +415,11 @@ void tst_QChangeArbiter::registerSceneObserver()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::NodeCreated);
     }
     Q_FOREACH (tst_SceneObserver *s, sceneObservers) {
         QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
     }
 
     // WHEN
@@ -429,33 +429,33 @@ void tst_QChangeArbiter::registerSceneObserver()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::ComponentAdded);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::ComponentAdded);
     }
     Q_FOREACH (tst_SceneObserver *s, sceneObservers) {
         QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
     }
 
-    Qt3D::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
 
 void tst_QChangeArbiter::unregisterObservers()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QChangeArbiter> arbiter(new Qt3D::QChangeArbiter());
-    QScopedPointer<Qt3D::QScene> scene(new Qt3D::QScene());
-    QScopedPointer<Qt3D::QAbstractPostman> postman(new tst_PostManObserver);
+    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
-    Qt3D::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
 
     // WHEN
     tst_Node *root = new tst_Node();
-    Qt3D::QNode *child = new tst_Node();
-    Qt3D::QNodePrivate::get(root)->setScene(scene.data());
+    Qt3DCore::QNode *child = new tst_Node();
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
     scene->addObservable(root);
 
     QList<tst_SimpleObserver *> observers;
@@ -478,7 +478,7 @@ void tst_QChangeArbiter::unregisterObservers()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::NodeCreated);
     }
 
     // WHEN
@@ -491,29 +491,29 @@ void tst_QChangeArbiter::unregisterObservers()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::NodeCreated);
     }
 
-    Qt3D::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
 
 void tst_QChangeArbiter::unregisterSceneObservers()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QChangeArbiter> arbiter(new Qt3D::QChangeArbiter());
-    QScopedPointer<Qt3D::QScene> scene(new Qt3D::QScene());
-    QScopedPointer<Qt3D::QAbstractPostman> postman(new tst_PostManObserver);
+    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
-    Qt3D::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
 
     // WHEN
     tst_Node *root = new tst_Node();
-    Qt3D::QNode *child = new tst_Node();
-    Qt3D::QNodePrivate::get(root)->setScene(scene.data());
+    Qt3DCore::QNode *child = new tst_Node();
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
     scene->addObservable(root);
 
     QList<tst_SimpleObserver *> observers;
@@ -545,11 +545,11 @@ void tst_QChangeArbiter::unregisterSceneObservers()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::NodeCreated);
     }
     Q_FOREACH (tst_SceneObserver *s, sceneObservers) {
         QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
     }
 
     // WHEN
@@ -559,11 +559,11 @@ void tst_QChangeArbiter::unregisterSceneObservers()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::ComponentAdded);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::ComponentAdded);
     }
     Q_FOREACH (tst_SceneObserver *s, sceneObservers) {
         QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeCreated);
     }
 
     // WHEN
@@ -573,11 +573,11 @@ void tst_QChangeArbiter::unregisterSceneObservers()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::NodeAboutToBeDeleted);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::NodeAboutToBeDeleted);
     }
     Q_FOREACH (tst_SceneObserver *s, sceneObservers) {
         QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3D::NodeAboutToBeDeleted);
+        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeAboutToBeDeleted);
     }
 
     Q_FOREACH (tst_SceneObserver *s, sceneObservers)
@@ -590,32 +590,32 @@ void tst_QChangeArbiter::unregisterSceneObservers()
     // THEN
     Q_FOREACH (tst_SimpleObserver *o, observers) {
         QVERIFY(!o->lastChange().isNull());
-        QVERIFY(o->lastChange()->type() == Qt3D::NodeCreated);
+        QVERIFY(o->lastChange()->type() == Qt3DCore::NodeCreated);
     }
     Q_FOREACH (tst_SceneObserver *s, sceneObservers) {
         QVERIFY(!s->lastChange().isNull());
-        QVERIFY(s->lastChange()->type() == Qt3D::NodeAboutToBeDeleted);
+        QVERIFY(s->lastChange()->type() == Qt3DCore::NodeAboutToBeDeleted);
     }
 
-    Qt3D::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
 
 void tst_QChangeArbiter::distributeFrontendChanges()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QChangeArbiter> arbiter(new Qt3D::QChangeArbiter());
-    QScopedPointer<Qt3D::QScene> scene(new Qt3D::QScene());
-    QScopedPointer<Qt3D::QAbstractPostman> postman(new tst_PostManObserver);
+    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
-    Qt3D::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
 
     // WHEN
     tst_Node *root = new tst_Node();
-    Qt3D::QNodePrivate::get(root)->setScene(scene.data());
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
     scene->addObservable(root);
 
     tst_SimpleObserver *backendAllChangedObserver = new tst_SimpleObserver();
@@ -626,11 +626,11 @@ void tst_QChangeArbiter::distributeFrontendChanges()
     tst_SimpleObserver *backendComponentRemovedObserver = new tst_SimpleObserver();
 
     arbiter->registerObserver(backendAllChangedObserver, root->id());
-    arbiter->registerObserver(backendNodeAddedObserver, root->id(), Qt3D::NodeAdded);
-    arbiter->registerObserver(backendNodeUpdatedObserver, root->id(), Qt3D::NodeUpdated);
-    arbiter->registerObserver(backendNodeRemovedObserver, root->id(), Qt3D::NodeRemoved);
-    arbiter->registerObserver(backendComponentAddedObserver, root->id(), Qt3D::ComponentAdded);
-    arbiter->registerObserver(backendComponentRemovedObserver, root->id(), Qt3D::ComponentRemoved);
+    arbiter->registerObserver(backendNodeAddedObserver, root->id(), Qt3DCore::NodeAdded);
+    arbiter->registerObserver(backendNodeUpdatedObserver, root->id(), Qt3DCore::NodeUpdated);
+    arbiter->registerObserver(backendNodeRemovedObserver, root->id(), Qt3DCore::NodeRemoved);
+    arbiter->registerObserver(backendComponentAddedObserver, root->id(), Qt3DCore::ComponentAdded);
+    arbiter->registerObserver(backendComponentRemovedObserver, root->id(), Qt3DCore::ComponentRemoved);
 
     arbiter->syncChanges();
 
@@ -714,22 +714,22 @@ void tst_QChangeArbiter::distributeFrontendChanges()
     QCOMPARE(backendComponentAddedObserver->lastChanges().count(), 2);
     QCOMPARE(backendComponentRemovedObserver->lastChanges().count(), 2);
 
-    Qt3D::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
 
 void tst_QChangeArbiter::distributeBackendChanges()
 {
 
     // GIVEN
-    QScopedPointer<Qt3D::QChangeArbiter> arbiter(new Qt3D::QChangeArbiter());
-    QScopedPointer<Qt3D::QScene> scene(new Qt3D::QScene());
+    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
-    Qt3D::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::createThreadLocalChangeQueue(arbiter.data());
 
     // In order for backend -> frontend changes to work properly,
     // the backend notification should only be sent
@@ -740,13 +740,13 @@ void tst_QChangeArbiter::distributeBackendChanges()
 
     // WHEN
     tst_Node *root = new tst_Node();
-    Qt3D::QNodePrivate::get(root)->setScene(scene.data());
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene.data());
     scene->addObservable(root);
 
     tst_BackendObserverObservable *backenObserverObservable = new tst_BackendObserverObservable();
-    arbiter->registerObserver(Qt3D::QBackendNodePrivate::get(backenObserverObservable), root->id());
-    arbiter->scene()->addObservable(Qt3D::QBackendNodePrivate::get(backenObserverObservable), root->id());
-    Qt3D::QBackendNodePrivate::get(backenObserverObservable)->setArbiter(arbiter.data());
+    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();
 
@@ -786,16 +786,16 @@ void tst_QChangeArbiter::distributeBackendChanges()
     QCOMPARE(postman->lastChanges().count(), 1);
 
     // verify correctness of the reply
-    Qt3D::QBackendScenePropertyChangePtr c = qSharedPointerDynamicCast<Qt3D::QBackendScenePropertyChange>(postman->lastChange());
+    Qt3DCore::QBackendScenePropertyChangePtr c = qSharedPointerDynamicCast<Qt3DCore::QBackendScenePropertyChange>(postman->lastChange());
     QVERIFY(!c.isNull());
     QVERIFY(c->targetNode() == root->id());
     qDebug() << c->propertyName();
     QVERIFY(strcmp(c->propertyName(), "Reply") == 0);
-    QVERIFY(c->type() == Qt3D::NodeUpdated);
+    QVERIFY(c->type() == Qt3DCore::NodeUpdated);
 
     answer->exit();
     answer->wait();
-    Qt3D::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
+    Qt3DCore::QChangeArbiter::destroyThreadLocalChangeQueue(arbiter.data());
 }
 
 QTEST_GUILESS_MAIN(tst_QChangeArbiter)
diff --git a/tests/auto/core/qcircularbuffer/tst_qcircularbuffer.cpp b/tests/auto/core/qcircularbuffer/tst_qcircularbuffer.cpp
index 8e76ce843..cc923d052 100644
--- a/tests/auto/core/qcircularbuffer/tst_qcircularbuffer.cpp
+++ b/tests/auto/core/qcircularbuffer/tst_qcircularbuffer.cpp
@@ -39,7 +39,7 @@
 
 #include <Qt3DCore/private/qcircularbuffer_p.h>
 
-using namespace Qt3D;
+using namespace Qt3DCore;
 
 class tst_QCircularBuffer : public QObject
 {
diff --git a/tests/auto/core/qentity/tst_qentity.cpp b/tests/auto/core/qentity/tst_qentity.cpp
index 2f7ebf314..042b62386 100644
--- a/tests/auto/core/qentity/tst_qentity.cpp
+++ b/tests/auto/core/qentity/tst_qentity.cpp
@@ -39,7 +39,7 @@
 #include <Qt3DCore/qcomponent.h>
 #include <QtCore/qscopedpointer.h>
 
-using namespace Qt3D;
+using namespace Qt3DCore;
 
 class tst_Entity : public QObject
 {
@@ -66,11 +66,11 @@ private slots:
     void verifyCopy();
 };
 
-class MyQComponent : public Qt3D::QComponent
+class MyQComponent : public Qt3DCore::QComponent
 {
     Q_OBJECT
 public:
-    explicit MyQComponent(Qt3D::QNode *parent = 0)
+    explicit MyQComponent(Qt3DCore::QNode *parent = 0)
         : QComponent(parent)
     {}
 
@@ -84,14 +84,14 @@ protected:
 };
 
 
-class MyEntity : public Qt3D::QEntity
+class MyEntity : public Qt3DCore::QEntity
 {
 public:
-    explicit MyEntity(Qt3D::QNode *parent = 0)
+    explicit MyEntity(Qt3DCore::QNode *parent = 0)
         : QEntity(parent)
     {}
 
-    void makeCopyOf(Qt3D::QEntity *other)
+    void makeCopyOf(Qt3DCore::QEntity *other)
     {
         QEntity::copy(other);
     }
@@ -119,7 +119,7 @@ void tst_Entity::constructionDestruction()
 void tst_Entity::addComponentSingleParentSingleAggregation()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity(new QEntity());
     MyQComponent *comp = new MyQComponent(entity.data());
     QCoreApplication::processEvents();
 
@@ -142,8 +142,8 @@ void tst_Entity::addComponentSingleParentSingleAggregation()
 void tst_Entity::addComponentSingleParentSeveralAggregations()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity1(new QEntity());
-    QScopedPointer<Qt3D::QEntity> entity2(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity1(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity2(new QEntity());
 
     MyQComponent *comp1 = new MyQComponent(entity1.data());
     MyQComponent *comp2 = new MyQComponent(entity1.data());
@@ -193,8 +193,8 @@ void tst_Entity::addComponentSingleParentSeveralAggregations()
 void tst_Entity::addComponentsSeveralParentsSingleAggregations()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity1(new QEntity());
-    QScopedPointer<Qt3D::QEntity> entity2(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity1(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity2(new QEntity());
 
     MyQComponent *comp1 = new MyQComponent(entity1.data());
     MyQComponent *comp2 = new MyQComponent(entity1.data());
@@ -241,8 +241,8 @@ void tst_Entity::addComponentsSeveralParentsSingleAggregations()
 void tst_Entity::addComponentsSeveralParentsSeveralAggregations()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity1(new QEntity());
-    QScopedPointer<Qt3D::QEntity> entity2(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity1(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity2(new QEntity());
 
     MyQComponent *comp1 = new MyQComponent(entity1.data());
     MyQComponent *comp2 = new MyQComponent(entity1.data());
@@ -292,7 +292,7 @@ void tst_Entity::addComponentsSeveralParentsSeveralAggregations()
 void tst_Entity::removeComponentSingleParentSingleAggregation()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity(new QEntity());
     MyQComponent *comp = new MyQComponent(entity.data());
     QCoreApplication::processEvents();
     entity->addComponent(comp);
@@ -316,8 +316,8 @@ void tst_Entity::removeComponentSingleParentSingleAggregation()
 void tst_Entity::removeComponentSingleParentSeveralAggregations()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity1(new QEntity());
-    QScopedPointer<Qt3D::QEntity> entity2(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity1(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity2(new QEntity());
 
     MyQComponent *comp1 = new MyQComponent(entity1.data());
     MyQComponent *comp2 = new MyQComponent(entity1.data());
@@ -391,8 +391,8 @@ void tst_Entity::removeComponentSingleParentSeveralAggregations()
 void tst_Entity::removeComponentsSeveralParentsSingleAggreation()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity1(new QEntity());
-    QScopedPointer<Qt3D::QEntity> entity2(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity1(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity2(new QEntity());
 
     MyQComponent *comp1 = new MyQComponent(entity1.data());
     MyQComponent *comp2 = new MyQComponent(entity1.data());
@@ -443,8 +443,8 @@ void tst_Entity::removeComponentsSeveralParentsSingleAggreation()
 void tst_Entity::removeComponentsSeveralParentsSeveralAggregations()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity1(new QEntity());
-    QScopedPointer<Qt3D::QEntity> entity2(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity1(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity2(new QEntity());
 
     MyQComponent *comp1 = new MyQComponent(entity1.data());
     MyQComponent *comp2 = new MyQComponent(entity1.data());
@@ -519,7 +519,7 @@ void tst_Entity::removeComponentsSeveralParentsSeveralAggregations()
 void tst_Entity::addSeveralTimesSameComponent()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity(new QEntity());
     MyQComponent *comp = new MyQComponent(entity.data());
     QCoreApplication::processEvents();
     entity->addComponent(comp);
@@ -543,7 +543,7 @@ void tst_Entity::addSeveralTimesSameComponent()
 void tst_Entity::removeSeveralTimesSameComponent()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> entity(new QEntity());
+    QScopedPointer<Qt3DCore::QEntity> entity(new QEntity());
     MyQComponent *comp = new MyQComponent(entity.data());
     QCoreApplication::processEvents();
     entity->addComponent(comp);
@@ -568,7 +568,7 @@ void tst_Entity::removeSeveralTimesSameComponent()
 void tst_Entity::verifyCopy()
 {
     // GIVEN
-    QScopedPointer<Qt3D::QEntity> root(new Qt3D::QEntity());
+    QScopedPointer<Qt3DCore::QEntity> root(new Qt3DCore::QEntity());
     MyEntity *parentLessEntity = new MyEntity();
     MyEntity *parentedEntity = new MyEntity(root.data());
 
diff --git a/tests/auto/core/qframeallocator/tst_qframeallocator.cpp b/tests/auto/core/qframeallocator/tst_qframeallocator.cpp
index e78cf568f..cf420bf19 100644
--- a/tests/auto/core/qframeallocator/tst_qframeallocator.cpp
+++ b/tests/auto/core/qframeallocator/tst_qframeallocator.cpp
@@ -110,7 +110,7 @@ private slots:
 
 void tst_QFrameAllocator::initQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
 
@@ -127,7 +127,7 @@ void tst_QFrameAllocator::initQFrameChunk()
 
 void tst_QFrameAllocator::singleAllocationQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
 
@@ -143,7 +143,7 @@ void tst_QFrameAllocator::singleAllocationQFrameChunk()
 
 void tst_QFrameAllocator::qvectorAllocationQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
 
@@ -159,7 +159,7 @@ void tst_QFrameAllocator::qvectorAllocationQFrameChunk()
 
 void tst_QFrameAllocator::multipleAllocationQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
 
@@ -180,7 +180,7 @@ void tst_QFrameAllocator::multipleAllocationQFrameChunk()
 
 void tst_QFrameAllocator::overflowAllocationQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
 
@@ -206,7 +206,7 @@ void tst_QFrameAllocator::overflowAllocationQFrameChunk()
 
 void tst_QFrameAllocator::singleDeallocationQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
 
@@ -227,7 +227,7 @@ void tst_QFrameAllocator::singleDeallocationQFrameChunk()
 
 void tst_QFrameAllocator::multipleDeallocationQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
 
@@ -291,8 +291,8 @@ void tst_QFrameAllocator::multipleDeallocationQFrameChunk()
 
 void tst_QFrameAllocator::containsCheckQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
-    Qt3D::QFrameChunk c2;
+    Qt3DCore::QFrameChunk c;
+    Qt3DCore::QFrameChunk c2;
 
     c.init(16, 12);
     c2.init(16, 12);
@@ -322,7 +322,7 @@ void tst_QFrameAllocator::containsCheckQFrameChunk()
 
 void tst_QFrameAllocator::clearQFrameChunk()
 {
-    Qt3D::QFrameChunk c;
+    Qt3DCore::QFrameChunk c;
 
     c.init(16, 12);
     QList<void *> ptrs;
@@ -342,7 +342,7 @@ void tst_QFrameAllocator::clearQFrameChunk()
 
 void tst_QFrameAllocator::initQFixedFrameAllocator()
 {
-    Qt3D::QFixedFrameAllocator f;
+    Qt3DCore::QFixedFrameAllocator f;
 
     f.init(4);
 
@@ -352,7 +352,7 @@ void tst_QFrameAllocator::initQFixedFrameAllocator()
 
 void tst_QFrameAllocator::allocateQFixedFrameAllocator()
 {
-    Qt3D::QFixedFrameAllocator f;
+    Qt3DCore::QFixedFrameAllocator f;
 
     f.init(4, 128);
 
@@ -390,7 +390,7 @@ void tst_QFrameAllocator::allocateQFixedFrameAllocator()
 
 void tst_QFrameAllocator::deallocateQFixedFrameAllocator()
 {
-    Qt3D::QFixedFrameAllocator f;
+    Qt3DCore::QFixedFrameAllocator f;
 
     f.init(4);
 
@@ -429,7 +429,7 @@ void tst_QFrameAllocator::deallocateQFixedFrameAllocator()
 
 void tst_QFrameAllocator::checkFragmentationQFixedFrameAllocator()
 {
-    Qt3D::QFixedFrameAllocator f;
+    Qt3DCore::QFixedFrameAllocator f;
 
     f.init(4);
 
@@ -459,7 +459,7 @@ void tst_QFrameAllocator::checkFragmentationQFixedFrameAllocator()
 
 void tst_QFrameAllocator::clearQFixedFrameAllocator()
 {
-    Qt3D::QFixedFrameAllocator f;
+    Qt3DCore::QFixedFrameAllocator f;
 
     f.init(16);
 
@@ -485,17 +485,17 @@ void tst_QFrameAllocator::clearQFixedFrameAllocator()
 
 void tst_QFrameAllocator::initQFrameAllocator()
 {
-    Qt3D::QFrameAllocator f(4, 4);
+    Qt3DCore::QFrameAllocator f(4, 4);
     QCOMPARE(f.allocatorPoolSize(), 1);
 
 
-    Qt3D::QFrameAllocator f2(32, 4);
+    Qt3DCore::QFrameAllocator f2(32, 4);
     QCOMPARE(f2.allocatorPoolSize(), 8);
 }
 
 void tst_QFrameAllocator::allocateWithQFrameAllocator()
 {
-    Qt3D::QFrameAllocator f2(256, 4);
+    Qt3DCore::QFrameAllocator f2(256, 4);
     QCOMPARE(f2.allocatorPoolSize(), 256 / 4);
 
     QVERIFY(f2.allocate<small>());
@@ -537,7 +537,7 @@ void tst_QFrameAllocator::allocateWithQFrameAllocator()
 
 void tst_QFrameAllocator::deallocateWithQFrameAllocator()
 {
-    Qt3D::QFrameAllocator f2(256, 4);
+    Qt3DCore::QFrameAllocator f2(256, 4);
     QCOMPARE(f2.allocatorPoolSize(), 256 / 4);
 
     small *s = f2.allocate<small>();
@@ -557,7 +557,7 @@ void tst_QFrameAllocator::deallocateWithQFrameAllocator()
 
 void tst_QFrameAllocator::testAllocationComposedValues()
 {
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
 
     composed t;
 
@@ -600,7 +600,7 @@ void tst_QFrameAllocator::testAllocationComposedValues()
 
 void tst_QFrameAllocator::allocateSubclass()
 {
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
 
     QList<composed *> composeds;
 
@@ -626,7 +626,7 @@ void tst_QFrameAllocator::allocateSubclass()
 
 void tst_QFrameAllocator::deallocateSubclass()
 {
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
 
 
     const int NUM_ITEMS = 256;
@@ -655,7 +655,7 @@ void tst_QFrameAllocator::deallocateSubclass()
 
 void tst_QFrameAllocator::clearQFrameAllocator()
 {
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
 
     for (int i = 0; i < 256; i++) {
         f.allocate<composed>();
@@ -683,7 +683,7 @@ void tst_QFrameAllocator::clearQFrameAllocator()
 void tst_QFrameAllocator::isEmptyQFrameAllocator()
 {
     // GIVEN
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
 
 
     // WHEN
@@ -720,7 +720,7 @@ void tst_QFrameAllocator::isEmptyQFrameAllocator()
 void tst_QFrameAllocator::subclassPointerClearing()
 {
     // GIVEN
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
     QVector<composed *> data;
 
     // WHEN
@@ -746,7 +746,7 @@ void tst_QFrameAllocator::subclassPointerClearing()
 void tst_QFrameAllocator::allocateWithRawMemoryDeallocate()
 {
     // GIVEN
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
     subclass *s = static_cast<subclass *>(f.allocateRawMemory(sizeof(subclass)));
     new (s) subclass();
 
@@ -760,7 +760,7 @@ void tst_QFrameAllocator::allocateWithRawMemoryDeallocate()
 void tst_QFrameAllocator::allocateDeallocateRawMemory()
 {
     // GIVEN
-    Qt3D::QFrameAllocator f(128, 32);
+    Qt3DCore::QFrameAllocator f(128, 32);
     subclass *s = f.allocate<subclass>();
 
     // WHEN
diff --git a/tests/auto/core/qray3d/tst_qray3d.cpp b/tests/auto/core/qray3d/tst_qray3d.cpp
index 1f4f829a2..00253d4c4 100644
--- a/tests/auto/core/qray3d/tst_qray3d.cpp
+++ b/tests/auto/core/qray3d/tst_qray3d.cpp
@@ -139,11 +139,11 @@ void tst_QRay3D::create()
 {
     QFETCH(QVector3D, point);
     QFETCH(QVector3D, direction);
-    Qt3D::QRay3D ray(point, direction);
+    Qt3DCore::QRay3D ray(point, direction);
     QVERIFY(fuzzyCompare(ray.direction(), direction));
     QVERIFY(fuzzyCompare(ray.origin(), point));
 
-    Qt3D::QRay3D ray2;
+    Qt3DCore::QRay3D ray2;
     QCOMPARE(ray2.origin(), QVector3D(0, 0, 0));
     QCOMPARE(ray2.direction(), QVector3D(0, 0, 1));
     ray2.setOrigin(point);
@@ -196,7 +196,7 @@ void tst_QRay3D::projection()
     QFETCH(QVector3D, direction);
     QFETCH(QVector3D, vector);
     QFETCH(QVector3D, expected);
-    Qt3D::QRay3D line(point, direction);
+    Qt3DCore::QRay3D line(point, direction);
     QVector3D result = line.project(vector);
     QVERIFY(fuzzyCompare(result, expected));
 }
@@ -245,7 +245,7 @@ void tst_QRay3D::point()
     QFETCH(QVector3D, direction);
     QFETCH(QVector3D, point_on_line_pos_0_6);
     QFETCH(QVector3D, point_on_line_neg_7_2);
-    Qt3D::QRay3D line(point, direction);
+    Qt3DCore::QRay3D line(point, direction);
     QVERIFY(fuzzyCompare(line.point(0.6), point_on_line_pos_0_6));
     QVERIFY(fuzzyCompare(line.point(-7.2), point_on_line_neg_7_2));
     QVERIFY(fuzzyCompare(line.projectedDistance(point_on_line_pos_0_6), 0.6));
@@ -335,7 +335,7 @@ void tst_QRay3D::contains_point()
     QFETCH(QVector3D, point);
     QFETCH(bool, contains);
 
-    Qt3D::QRay3D line(origin, direction);
+    Qt3DCore::QRay3D line(origin, direction);
     QCOMPARE(line.contains(point), contains);
 }
 
@@ -351,23 +351,23 @@ void tst_QRay3D::contains_ray()
     QFETCH(QVector3D, point);
     QFETCH(bool, contains);
 
-    Qt3D::QRay3D line(origin, direction);
+    Qt3DCore::QRay3D line(origin, direction);
     if (contains) {
-        Qt3D::QRay3D line2(point, direction);
+        Qt3DCore::QRay3D line2(point, direction);
         QVERIFY(line.contains(line2));
         QVERIFY(line2.contains(line));
 
         // Reversed direction is also contained.
-        Qt3D::QRay3D line3(point, -direction);
+        Qt3DCore::QRay3D line3(point, -direction);
         QVERIFY(line.contains(line2));
         QVERIFY(line2.contains(line));
 
         // Different direction.
-        Qt3D::QRay3D line4(point, QVector3D(direction.y(), direction.x(), direction.z()));
+        Qt3DCore::QRay3D line4(point, QVector3D(direction.y(), direction.x(), direction.z()));
         QVERIFY(!line.contains(line4));
         QVERIFY(!line4.contains(line));
     } else {
-        Qt3D::QRay3D line2(point, direction);
+        Qt3DCore::QRay3D line2(point, direction);
         QVERIFY(!line.contains(line2));
         QVERIFY(!line2.contains(line));
     }
@@ -412,15 +412,15 @@ void tst_QRay3D::distance()
     QFETCH(QVector3D, point);
     QFETCH(float, distance);
 
-    Qt3D::QRay3D line(origin, direction);
+    Qt3DCore::QRay3D line(origin, direction);
     QCOMPARE(line.distance(point), distance);
 }
 
 void tst_QRay3D::compare()
 {
-    Qt3D::QRay3D ray1(QVector3D(10, 20, 30), QVector3D(-3, -4, -5));
-    Qt3D::QRay3D ray2(QVector3D(10, 20, 30), QVector3D(1.5f, 2.0f, 2.5f));
-    Qt3D::QRay3D ray3(QVector3D(0, 20, 30), QVector3D(-3, -4, -5));
+    Qt3DCore::QRay3D ray1(QVector3D(10, 20, 30), QVector3D(-3, -4, -5));
+    Qt3DCore::QRay3D ray2(QVector3D(10, 20, 30), QVector3D(1.5f, 2.0f, 2.5f));
+    Qt3DCore::QRay3D ray3(QVector3D(0, 20, 30), QVector3D(-3, -4, -5));
     QVERIFY(ray1 == ray1);
     QVERIFY(!(ray1 != ray1));
     QVERIFY(qFuzzyCompare(ray1, ray1));
@@ -435,7 +435,7 @@ void tst_QRay3D::compare()
 void tst_QRay3D::dataStream()
 {
 #ifndef QT_NO_DATASTREAM
-    Qt3D::QRay3D ray(QVector3D(1.0f, 2.0f, 3.0f), QVector3D(4.0f, 5.0f, 6.0f));
+    Qt3DCore::QRay3D ray(QVector3D(1.0f, 2.0f, 3.0f), QVector3D(4.0f, 5.0f, 6.0f));
 
     QByteArray data;
     {
@@ -443,7 +443,7 @@ void tst_QRay3D::dataStream()
         stream << ray;
     }
 
-    Qt3D::QRay3D ray2;
+    Qt3DCore::QRay3D ray2;
     {
         QDataStream stream2(data);
         stream2 >> ray2;
@@ -468,9 +468,9 @@ void tst_QRay3D::transform()
     m.rotate(45.0f, 1.0f, 1.0f, 1.0f);
     m.scale(23.5f);
 
-    Qt3D::QRay3D ray1(point, direction);
-    Qt3D::QRay3D ray2(ray1);
-    Qt3D::QRay3D ray3;
+    Qt3DCore::QRay3D ray1(point, direction);
+    Qt3DCore::QRay3D ray2(ray1);
+    Qt3DCore::QRay3D ray3;
 
     ray1.transform(m);
     ray3 = ray2.transformed(m);
@@ -485,15 +485,15 @@ void tst_QRay3D::transform()
 class tst_QRay3DProperties : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(Qt3D::QRay3D ray READ ray WRITE setRay)
+    Q_PROPERTY(Qt3DCore::QRay3D ray READ ray WRITE setRay)
 public:
     tst_QRay3DProperties(QObject *parent = 0) : QObject(parent) {}
 
-    Qt3D::QRay3D ray() const { return r; }
-    void setRay(const Qt3D::QRay3D& value) { r = value; }
+    Qt3DCore::QRay3D ray() const { return r; }
+    void setRay(const Qt3DCore::QRay3D& value) { r = value; }
 
 private:
-    Qt3D::QRay3D r;
+    Qt3DCore::QRay3D r;
 };
 
 // Test getting and setting properties via the metaobject system.
@@ -501,35 +501,35 @@ void tst_QRay3D::properties()
 {
     tst_QRay3DProperties obj;
 
-    qRegisterMetaType<Qt3D::QRay3D>();
+    qRegisterMetaType<Qt3DCore::QRay3D>();
 
-    obj.setRay(Qt3D::QRay3D(QVector3D(1, 2, 3), QVector3D(4, 5, 6)));
+    obj.setRay(Qt3DCore::QRay3D(QVector3D(1, 2, 3), QVector3D(4, 5, 6)));
 
-    Qt3D::QRay3D r = qvariant_cast<Qt3D::QRay3D>(obj.property("ray"));
+    Qt3DCore::QRay3D r = qvariant_cast<Qt3DCore::QRay3D>(obj.property("ray"));
     QCOMPARE(r.origin(), QVector3D(1, 2, 3));
     QCOMPARE(r.direction(), QVector3D(4, 5, 6));
 
     obj.setProperty("ray",
                     qVariantFromValue
-                        (Qt3D::QRay3D(QVector3D(-1, -2, -3), QVector3D(-4, -5, -6))));
+                        (Qt3DCore::QRay3D(QVector3D(-1, -2, -3), QVector3D(-4, -5, -6))));
 
-    r = qvariant_cast<Qt3D::QRay3D>(obj.property("ray"));
+    r = qvariant_cast<Qt3DCore::QRay3D>(obj.property("ray"));
     QCOMPARE(r.origin(), QVector3D(-1, -2, -3));
     QCOMPARE(r.direction(), QVector3D(-4, -5, -6));
 }
 
 void tst_QRay3D::metaTypes()
 {
-    int id = qMetaTypeId<Qt3D::QRay3D>();
-    QVERIFY(QMetaType::type("Qt3D::QRay3D") == id);
-    QCOMPARE(QByteArray(QMetaType::typeName(id)), QByteArray("Qt3D::QRay3D"));
+    int id = qMetaTypeId<Qt3DCore::QRay3D>();
+    QVERIFY(QMetaType::type("Qt3DCore::QRay3D") == id);
+    QCOMPARE(QByteArray(QMetaType::typeName(id)), QByteArray("Qt3DCore::QRay3D"));
     QVERIFY(QMetaType::isRegistered(id));
 }
 
 void tst_QRay3D::shouldNotAllowNullDirection()
 {
     // GIVEN
-    Qt3D::QRay3D ray;
+    Qt3DCore::QRay3D ray;
 
     QCOMPARE(ray.origin(), QVector3D(0, 0, 0));
     QCOMPARE(ray.direction(), QVector3D(0, 0, 1));
diff --git a/tests/auto/core/qscene/tst_qscene.cpp b/tests/auto/core/qscene/tst_qscene.cpp
index e5d30eccf..a907a62ba 100644
--- a/tests/auto/core/qscene/tst_qscene.cpp
+++ b/tests/auto/core/qscene/tst_qscene.cpp
@@ -62,34 +62,34 @@ private slots:
     void hasEntityForComponent();
 };
 
-class tst_LockableObserver : public Qt3D::QLockableObserverInterface
+class tst_LockableObserver : public Qt3DCore::QLockableObserverInterface
 {
 public:
-    void sceneChangeEvent(const Qt3D::QSceneChangePtr &) Q_DECL_OVERRIDE {}
-    void sceneChangeEventWithLock(const Qt3D::QSceneChangePtr &) Q_DECL_OVERRIDE {}
-    void sceneChangeEventWithLock(const Qt3D::QSceneChangeList &) Q_DECL_OVERRIDE {}
+    void sceneChangeEvent(const Qt3DCore::QSceneChangePtr &) Q_DECL_OVERRIDE {}
+    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangePtr &) Q_DECL_OVERRIDE {}
+    void sceneChangeEventWithLock(const Qt3DCore::QSceneChangeList &) Q_DECL_OVERRIDE {}
 };
 
-class tst_Observable : public Qt3D::QObservableInterface
+class tst_Observable : public Qt3DCore::QObservableInterface
 {
 public:
-    void setArbiter(Qt3D::QLockableObserverInterface *observer)
+    void setArbiter(Qt3DCore::QLockableObserverInterface *observer)
     {
         m_arbiter = observer;
     }
 
 protected:
-    void notifyObservers(const Qt3D::QSceneChangePtr &) {}
+    void notifyObservers(const Qt3DCore::QSceneChangePtr &) {}
 
 private:
-    Qt3D::QLockableObserverInterface *m_arbiter;
+    Qt3DCore::QLockableObserverInterface *m_arbiter;
 };
 
-class tst_Node : public Qt3D::QNode
+class tst_Node : public Qt3DCore::QNode
 {
     Q_OBJECT
 public:
-    tst_Node() : Qt3D::QNode()
+    tst_Node() : Qt3DCore::QNode()
     {}
 
     ~tst_Node()
@@ -101,11 +101,11 @@ protected:
     QT3D_CLONEABLE(tst_Node)
 };
 
-class tst_Component : public Qt3D::QComponent
+class tst_Component : public Qt3DCore::QComponent
 {
     Q_OBJECT
 public:
-    tst_Component() : Qt3D::QComponent()
+    tst_Component() : Qt3DCore::QComponent()
     {}
 
     ~tst_Component()
@@ -120,15 +120,15 @@ protected:
 void tst_QScene::addObservable()
 {
     // GIVEN
-    Qt3D::QNode *node1 = new tst_Node();
-    Qt3D::QNode *node2 = new tst_Node();
+    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());
 
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
     scene->setArbiter(new tst_LockableObserver);
 
     // WHEN
@@ -138,18 +138,18 @@ void tst_QScene::addObservable()
     for (int i = 0; i < 5; i++)
         scene->addObservable(observables.at(i + 5), node2->id());
 
-    Qt3D::QObservableList obs1 = scene->lookupObservables(node1->id());
-    Qt3D::QObservableList obs2 = scene->lookupObservables(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());
 
-    Q_FOREACH (Qt3D::QObservableInterface *o, obs1) {
+    Q_FOREACH (Qt3DCore::QObservableInterface *o, obs1) {
         QVERIFY(scene->nodeIdFromObservable(o) == node1->id());
         QVERIFY(scene->lookupNode(node1->id()) == Q_NULLPTR);
     }
-    Q_FOREACH (Qt3D::QObservableInterface *o, obs2) {
+    Q_FOREACH (Qt3DCore::QObservableInterface *o, obs2) {
         QVERIFY(scene->nodeIdFromObservable(o) == node2->id());
         QVERIFY(scene->lookupNode(node2->id()) == Q_NULLPTR);
     }
@@ -158,12 +158,12 @@ void tst_QScene::addObservable()
 void tst_QScene::addNodeObservable()
 {
     // GIBEN
-    QList<Qt3D::QNode *> nodes;
+    QList<Qt3DCore::QNode *> nodes;
 
     for (int i = 0; i < 10; i++)
         nodes.append(new tst_Node());
 
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
     scene->setArbiter(new tst_LockableObserver);
 
     // WHEN
@@ -171,7 +171,7 @@ void tst_QScene::addNodeObservable()
         scene->addObservable(nodes.at(i));
 
     // THEN
-    Q_FOREACH (Qt3D::QNode *n, nodes) {
+    Q_FOREACH (Qt3DCore::QNode *n, nodes) {
         QVERIFY(n == scene->lookupNode(n->id()));
         QVERIFY(scene->lookupObservables(n->id()).isEmpty());
     }
@@ -180,15 +180,15 @@ void tst_QScene::addNodeObservable()
 void tst_QScene::removeObservable()
 {
     // GIVEN
-    Qt3D::QNode *node1 = new tst_Node();
-    Qt3D::QNode *node2 = new tst_Node();
+    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());
 
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
     scene->setArbiter(new tst_LockableObserver);
 
     // WHEN
@@ -198,8 +198,8 @@ void tst_QScene::removeObservable()
     for (int i = 0; i < 5; i++)
         scene->addObservable(observables.at(i + 5), node2->id());
 
-    Qt3D::QObservableList obs1 = scene->lookupObservables(node1->id());
-    Qt3D::QObservableList obs2 = scene->lookupObservables(node2->id());
+    Qt3DCore::QObservableList obs1 = scene->lookupObservables(node1->id());
+    Qt3DCore::QObservableList obs2 = scene->lookupObservables(node2->id());
 
     // THEN
     QCOMPARE(obs1.count(), 5);
@@ -225,21 +225,21 @@ void tst_QScene::removeObservable()
     scene->removeObservable(observables.at(0), node2->id());
     // THEN
     QCOMPARE(scene->lookupObservables(node2->id()).count(), 5);
-    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3D::QNodeId());
+    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3DCore::QNodeId());
 }
 
 void tst_QScene::removeNodeObservable()
 {
     // GIVEN
-    Qt3D::QNode *node1 = new tst_Node();
-    Qt3D::QNode *node2 = new tst_Node();
+    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());
 
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
     scene->setArbiter(new tst_LockableObserver);
 
     // WHEN
@@ -253,8 +253,8 @@ void tst_QScene::removeNodeObservable()
         scene->addObservable(observables.at(i + 5), node2->id());
 
     // THEN
-    Qt3D::QObservableList obs1 = scene->lookupObservables(node1->id());
-    Qt3D::QObservableList obs2 = scene->lookupObservables(node2->id());
+    Qt3DCore::QObservableList obs1 = scene->lookupObservables(node1->id());
+    Qt3DCore::QObservableList obs2 = scene->lookupObservables(node2->id());
 
     QCOMPARE(obs1.count(), 5);
     QCOMPARE(obs2.count(), obs1.count());
@@ -265,7 +265,7 @@ void tst_QScene::removeNodeObservable()
     // THEN
     QVERIFY(scene->lookupNode(node1->id()) == Q_NULLPTR);
     QVERIFY(scene->lookupObservables(node1->id()).empty());
-    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3D::QNodeId());
+    QVERIFY(scene->nodeIdFromObservable(observables.at(0)) == Qt3DCore::QNodeId());
 
     QVERIFY(scene->lookupNode(node2->id()) == node2);
     QCOMPARE(scene->lookupObservables(node2->id()).count(), 5);
@@ -275,12 +275,12 @@ void tst_QScene::removeNodeObservable()
 void tst_QScene::addChildNode()
 {
     // GIVEN
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
 
-    QList<Qt3D::QNode *> nodes;
+    QList<Qt3DCore::QNode *> nodes;
 
-    Qt3D::QNode *root = new tst_Node();
-    Qt3D::QNodePrivate::get(root)->setScene(scene);
+    Qt3DCore::QNode *root = new tst_Node();
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene);
 
     // WHEN
     scene->addObservable(root);
@@ -289,7 +289,7 @@ void tst_QScene::addChildNode()
 
     // WHEN
     for (int i = 0; i < 10; i++) {
-        Qt3D::QNode *child = new tst_Node();
+        Qt3DCore::QNode *child = new tst_Node();
         if (nodes.isEmpty())
             child->setParent(root);
         else
@@ -299,7 +299,7 @@ void tst_QScene::addChildNode()
     QCoreApplication::processEvents();
 
     // THEN
-    Q_FOREACH (Qt3D::QNode *n, nodes) {
+    Q_FOREACH (Qt3DCore::QNode *n, nodes) {
         QVERIFY(scene->lookupNode(n->id()) == n);
     }
 }
@@ -307,17 +307,17 @@ void tst_QScene::addChildNode()
 void tst_QScene::removeChildNode()
 {
     // GIVEN
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
 
-    QList<Qt3D::QNode *> nodes;
+    QList<Qt3DCore::QNode *> nodes;
 
-    Qt3D::QNode *root = new tst_Node;
-    Qt3D::QNodePrivate::get(root)->setScene(scene);
+    Qt3DCore::QNode *root = new tst_Node;
+    Qt3DCore::QNodePrivate::get(root)->setScene(scene);
     scene->addObservable(root);
 
     // WHEN
     for (int i = 0; i < 10; i++) {
-        Qt3D::QNode *child = new tst_Node;
+        Qt3DCore::QNode *child = new tst_Node;
         if (nodes.isEmpty())
             child->setParent(root);
         else
@@ -327,7 +327,7 @@ void tst_QScene::removeChildNode()
 
     // THEN
     while (!nodes.isEmpty()) {
-        Qt3D::QNode *lst = nodes.takeLast();
+        Qt3DCore::QNode *lst = nodes.takeLast();
         QVERIFY(scene->lookupNode(lst->id()) == lst);
         if (lst->parentNode() != Q_NULLPTR) {
             lst->setParent(Q_NODE_NULLPTR);
@@ -340,24 +340,24 @@ void tst_QScene::removeChildNode()
 void tst_QScene::addEntityForComponent()
 {
     // GIVEN
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
 
-    QList<Qt3D::QEntity *> entities;
-    QList<Qt3D::QComponent *> components;
+    QList<Qt3DCore::QEntity *> entities;
+    QList<Qt3DCore::QComponent *> components;
 
     for (int i = 0; i < 10; i++) {
-        Qt3D::QEntity *entity = new Qt3D::QEntity();
-        Qt3D::QComponent *comp = new tst_Component();
+        Qt3DCore::QEntity *entity = new Qt3DCore::QEntity();
+        Qt3DCore::QComponent *comp = new tst_Component();
 
-        Qt3D::QNodePrivate::get(entity)->setScene(scene);
-        Qt3D::QNodePrivate::get(comp)->setScene(scene);
+        Qt3DCore::QNodePrivate::get(entity)->setScene(scene);
+        Qt3DCore::QNodePrivate::get(comp)->setScene(scene);
         entities << entity;
         components << comp;
     }
 
     // WHEN
     for (int i = 0; i < 10; i++) {
-        Qt3D::QEntity *e = entities.at(i);
+        Qt3DCore::QEntity *e = entities.at(i);
         for (int j = 0; j < 10; j++) {
             e->addComponent(components.at(j));
         }
@@ -365,7 +365,7 @@ void tst_QScene::addEntityForComponent()
 
     // THEN
     for (int i = 0; i < 10; i++) {
-        QList<Qt3D::QNodeId> ids = scene->entitiesForComponent(components.at(i)->id());
+        QList<Qt3DCore::QNodeId> ids = scene->entitiesForComponent(components.at(i)->id());
         QCOMPARE(ids.count(), 10);
     }
 }
@@ -373,24 +373,24 @@ void tst_QScene::addEntityForComponent()
 void tst_QScene::removeEntityForComponent()
 {
     // GIVEN
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
 
-    QList<Qt3D::QEntity *> entities;
-    QList<Qt3D::QComponent *> components;
+    QList<Qt3DCore::QEntity *> entities;
+    QList<Qt3DCore::QComponent *> components;
 
     for (int i = 0; i < 10; i++) {
-        Qt3D::QEntity *entity = new Qt3D::QEntity();
-        Qt3D::QComponent *comp = new tst_Component();
+        Qt3DCore::QEntity *entity = new Qt3DCore::QEntity();
+        Qt3DCore::QComponent *comp = new tst_Component();
 
-        Qt3D::QNodePrivate::get(entity)->setScene(scene);
-        Qt3D::QNodePrivate::get(comp)->setScene(scene);
+        Qt3DCore::QNodePrivate::get(entity)->setScene(scene);
+        Qt3DCore::QNodePrivate::get(comp)->setScene(scene);
         entities << entity;
         components << comp;
     }
 
     // WHEN
     for (int i = 0; i < 10; i++) {
-        Qt3D::QEntity *e = entities.at(i);
+        Qt3DCore::QEntity *e = entities.at(i);
         for (int j = 0; j < 10; j++) {
             e->addComponent(components.at(j));
         }
@@ -398,7 +398,7 @@ void tst_QScene::removeEntityForComponent()
 
     // THEN
     for (int i = 0; i < 10; i++) {
-        Qt3D::QEntity *e = entities.at(i);
+        Qt3DCore::QEntity *e = entities.at(i);
         for (int j = 0; j < 10; j++) {
             e->removeComponent(components.at(j));
             QCOMPARE(scene->entitiesForComponent(components.at(j)->id()).count(), 10 - (i + 1));
@@ -409,24 +409,24 @@ void tst_QScene::removeEntityForComponent()
 void tst_QScene::hasEntityForComponent()
 {
     // GIVEN
-    Qt3D::QScene *scene = new Qt3D::QScene;
+    Qt3DCore::QScene *scene = new Qt3DCore::QScene;
 
-    QList<Qt3D::QEntity *> entities;
-    QList<Qt3D::QComponent *> components;
+    QList<Qt3DCore::QEntity *> entities;
+    QList<Qt3DCore::QComponent *> components;
 
     for (int i = 0; i < 10; i++) {
-        Qt3D::QEntity *entity = new Qt3D::QEntity();
-        Qt3D::QComponent *comp = new tst_Component();
+        Qt3DCore::QEntity *entity = new Qt3DCore::QEntity();
+        Qt3DCore::QComponent *comp = new tst_Component();
 
-        Qt3D::QNodePrivate::get(entity)->setScene(scene);
-        Qt3D::QNodePrivate::get(comp)->setScene(scene);
+        Qt3DCore::QNodePrivate::get(entity)->setScene(scene);
+        Qt3DCore::QNodePrivate::get(comp)->setScene(scene);
         entities << entity;
         components << comp;
     }
 
     // WHEN
     for (int i = 0; i < 10; i++) {
-        Qt3D::QEntity *e = entities.at(i);
+        Qt3DCore::QEntity *e = entities.at(i);
         for (int j = 0; j < 10; j++) {
             e->addComponent(components.at(j));
         }
diff --git a/tests/auto/core/qservicelocator/tst_qservicelocator.cpp b/tests/auto/core/qservicelocator/tst_qservicelocator.cpp
index 8c578cd22..3bb1eb8b1 100644
--- a/tests/auto/core/qservicelocator/tst_qservicelocator.cpp
+++ b/tests/auto/core/qservicelocator/tst_qservicelocator.cpp
@@ -41,7 +41,7 @@
 
 #include <QScopedPointer>
 
-using namespace Qt3D;
+using namespace Qt3DCore;
 
 class DummyService : public QAbstractServiceProvider
 {
diff --git a/tests/auto/core/threadpooler/tst_threadpooler.cpp b/tests/auto/core/threadpooler/tst_threadpooler.cpp
index e3adbeba0..177d7ff16 100644
--- a/tests/auto/core/threadpooler/tst_threadpooler.cpp
+++ b/tests/auto/core/threadpooler/tst_threadpooler.cpp
@@ -61,7 +61,7 @@ public:
     ~tst_ThreadPooler() {}
 
 private:
-    Qt3D::QAspectJobManager *m_jobManager;
+    Qt3DCore::QAspectJobManager *m_jobManager;
 
 private Q_SLOTS:
     void init();
@@ -75,7 +75,7 @@ private Q_SLOTS:
     void perThreadUniqueCall();
 };
 
-typedef Qt3D::QAspectJobManager JobManager;
+typedef Qt3DCore::QAspectJobManager JobManager;
 typedef void (*TestFunction)(QAtomicInt *, int *);
 typedef void (*MassFunction)(QVector3D *data);
 
@@ -86,7 +86,7 @@ void perThreadFunction(void *arg)
 
 // General test AspectJob
 
-class TestAspectJob : public Qt3D::QAspectJob
+class TestAspectJob : public Qt3DCore::QAspectJob
 {
 public:
     TestAspectJob(TestFunction func, QAtomicInt *counter, int *value);
@@ -121,7 +121,7 @@ void TestAspectJob::run()
 
 // Mass test AspectJob
 
-class MassAspectJob : public Qt3D::QAspectJob
+class MassAspectJob : public Qt3DCore::QAspectJob
 {
 public:
     MassAspectJob(MassFunction func, QVector3D *data);
@@ -215,7 +215,7 @@ void tst_ThreadPooler::defaultAspectQueue()
     // GIVEN
     QAtomicInt callCounter;
     int value = 0; // Not used in this test
-    QVector<QSharedPointer<Qt3D::QAspectJob> > jobList;
+    QVector<QSharedPointer<Qt3DCore::QAspectJob> > jobList;
     callCounter.store(0);
     const int jobCount = 5;
 
@@ -241,7 +241,7 @@ void tst_ThreadPooler::doubleAspectQueue()
     // GIVEN
     QAtomicInt callCounter;
     int value = 0; // Not used in this test
-    QVector<QSharedPointer<Qt3D::QAspectJob> > jobList;
+    QVector<QSharedPointer<Qt3DCore::QAspectJob> > jobList;
     callCounter.store(0);
     const int jobCount = 3;
 
@@ -253,7 +253,7 @@ void tst_ThreadPooler::doubleAspectQueue()
     }
     m_jobManager->enqueueJobs(jobList);
 
-    QVector<QSharedPointer<Qt3D::QAspectJob> > jobList2;
+    QVector<QSharedPointer<Qt3DCore::QAspectJob> > jobList2;
     for (int i = 0; i < jobCount; i++) {
         QSharedPointer<TestAspectJob> job(new TestAspectJob(incrementFunctionCallCounter,
                                                             &callCounter, &value));
@@ -275,7 +275,7 @@ void tst_ThreadPooler::dependencyAspectQueue()
     // GIVEN
     QAtomicInt callCounter; // Not used in this test
     int value = 2;
-    QVector<QSharedPointer<Qt3D::QAspectJob> > jobList;
+    QVector<QSharedPointer<Qt3DCore::QAspectJob> > jobList;
 
     // WHEN
     QSharedPointer<TestAspectJob> job1(new TestAspectJob(add2, &callCounter, &value));
@@ -295,7 +295,7 @@ void tst_ThreadPooler::massTest()
 {
     // GIVEN
     const int mass = 600; // 600
-    QVector<QSharedPointer<Qt3D::QAspectJob> > jobList;
+    QVector<QSharedPointer<Qt3DCore::QAspectJob> > jobList;
     QVector3D data[3 * mass];
 
     // WHEN