Move Render aspect into the Qt3DRender namespace

Updated examples and tests accordingly.

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

20 files changed, 307 insertions, 303 deletions

diff --git a/tests/auto/render/meshfunctors/tst_meshfunctors.cpp b/tests/auto/render/meshfunctors/tst_meshfunctors.cpp
index a7d0f91a7..36a0f7316 100644
--- a/tests/auto/render/meshfunctors/tst_meshfunctors.cpp
+++ b/tests/auto/render/meshfunctors/tst_meshfunctors.cpp
@@ -38,7 +38,7 @@
 #include <Qt3DRenderer/qgeometryfunctor.h>
 #include <Qt3DRenderer/qgeometry.h>
 
-class MeshFunctorA : public Qt3D::QGeometryFunctor
+class MeshFunctorA : public Qt3DRender::QGeometryFunctor
 {
 public:
     MeshFunctorA()
@@ -47,12 +47,12 @@ public:
     ~MeshFunctorA()
     {}
 
-    Qt3D::QGeometry *operator ()() Q_DECL_OVERRIDE
+    Qt3DRender::QGeometry *operator ()() Q_DECL_OVERRIDE
     {
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3D::QGeometryFunctor &other) const Q_DECL_OVERRIDE
+    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const Q_DECL_OVERRIDE
     {
         return functor_cast<MeshFunctorA>(&other);
     }
@@ -60,7 +60,7 @@ public:
     QT3D_FUNCTOR(MeshFunctorA)
 };
 
-class MeshFunctorB : public Qt3D::QGeometryFunctor
+class MeshFunctorB : public Qt3DRender::QGeometryFunctor
 {
 public:
     MeshFunctorB()
@@ -69,12 +69,12 @@ public:
     ~MeshFunctorB()
     {}
 
-    Qt3D::QGeometry *operator ()() Q_DECL_OVERRIDE
+    Qt3DRender::QGeometry *operator ()() Q_DECL_OVERRIDE
     {
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3D::QGeometryFunctor &other) const Q_DECL_OVERRIDE
+    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const Q_DECL_OVERRIDE
     {
         return functor_cast<MeshFunctorB>(&other);
     }
@@ -91,7 +91,7 @@ public:
     ~MeshFunctorASub()
     {}
 
-    bool operator ==(const Qt3D::QGeometryFunctor &other) const Q_DECL_OVERRIDE
+    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const Q_DECL_OVERRIDE
     {
         return functor_cast<MeshFunctorASub>(&other);
     }
diff --git a/tests/auto/render/qattribute/tst_qattribute.cpp b/tests/auto/render/qattribute/tst_qattribute.cpp
index 889a9c244..937e9c200 100644
--- a/tests/auto/render/qattribute/tst_qattribute.cpp
+++ b/tests/auto/render/qattribute/tst_qattribute.cpp
@@ -134,13 +134,13 @@ private Q_SLOTS:
 
     void checkCloning_data()
     {
-        QTest::addColumn<Qt3D::QAttribute *>("attribute");
+        QTest::addColumn<Qt3DRender::QAttribute *>("attribute");
 
-        Qt3D::QAttribute *defaultConstructed = new Qt3D::QAttribute();
+        Qt3DRender::QAttribute *defaultConstructed = new Qt3DRender::QAttribute();
         QTest::newRow("defaultConstructed") << defaultConstructed;
 
-        Qt3D::QAttribute *customVertex = new Qt3D::QAttribute();
-        Qt3D::QBuffer *buffer = new Qt3D::QBuffer(Qt3D::QBuffer::VertexBuffer);
+        Qt3DRender::QAttribute *customVertex = new Qt3DRender::QAttribute();
+        Qt3DRender::QBuffer *buffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::VertexBuffer);
         customVertex->setBuffer(buffer);
         customVertex->setAttributeType(Qt3D::QAbstractAttribute::VertexAttribute);
         customVertex->setCount(454);
@@ -148,12 +148,12 @@ private Q_SLOTS:
         customVertex->setByteOffset(305);
         customVertex->setDivisor(235);
         customVertex->setName("BB");
-        customVertex->setDataType(Qt3D::QAttribute::Float);
+        customVertex->setDataType(Qt3DRender::QAttribute::Float);
         customVertex->setDataSize(4);
         QTest::newRow("vertex") << customVertex;
 
-        Qt3D::QAttribute *customIndex = new Qt3D::QAttribute();
-        Qt3D::QBuffer *indexBuffer = new Qt3D::QBuffer(Qt3D::QBuffer::IndexBuffer);
+        Qt3DRender::QAttribute *customIndex = new Qt3DRender::QAttribute();
+        Qt3DRender::QBuffer *indexBuffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::IndexBuffer);
         customIndex->setBuffer(indexBuffer);
         customIndex->setAttributeType(Qt3D::QAbstractAttribute::IndexAttribute);
         customIndex->setCount(383);
@@ -161,7 +161,7 @@ private Q_SLOTS:
         customIndex->setByteOffset(327);
         customIndex->setDivisor(355);
         customIndex->setName("SB");
-        customIndex->setDataType(Qt3D::QAttribute::Float);
+        customIndex->setDataType(Qt3DRender::QAttribute::Float);
         customIndex->setDataSize(3);
         QTest::newRow("index") << customIndex;
     }
@@ -169,10 +169,10 @@ private Q_SLOTS:
     void checkCloning()
     {
         // GIVEN
-        QFETCH(Qt3D::QAttribute *, attribute);
+        QFETCH(Qt3DRender::QAttribute *, attribute);
 
         // WHEN
-        Qt3D::QAttribute *clone = static_cast<Qt3D::QAttribute *>(QNode::clone(attribute));
+        Qt3DRender::QAttribute *clone = static_cast<Qt3DRender::QAttribute *>(QNode::clone(attribute));
         QCoreApplication::processEvents();
 
         // THEN
@@ -198,18 +198,18 @@ private Q_SLOTS:
     void checkPropertyUpdates()
     {
         // GIVEN
-        QScopedPointer<Qt3D::QAttribute> attribute(new Qt3D::QAttribute());
+        QScopedPointer<Qt3DRender::QAttribute> attribute(new Qt3DRender::QAttribute());
         TestArbiter arbiter(attribute.data());
 
         // WHEN
-        attribute->setDataType(Qt3D::QAttribute::Double);
+        attribute->setDataType(Qt3DRender::QAttribute::Double);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
         Qt3D::QScenePropertyChangePtr change = arbiter.events.first().staticCast<Qt3D::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "dataType");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3D::QAttribute::Double));
+        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QAttribute::Double));
         QCOMPARE(change->type(), Qt3D::NodeUpdated);
 
         arbiter.events.clear();
@@ -306,7 +306,7 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN
-        Qt3D::QBuffer buf;
+        Qt3DRender::QBuffer buf;
         attribute->setBuffer(&buf);
         QCoreApplication::processEvents();
 
@@ -320,7 +320,7 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN
-        Qt3D::QBuffer buf2;
+        Qt3DRender::QBuffer buf2;
         attribute->setBuffer(&buf2);
         QCoreApplication::processEvents();
 
diff --git a/tests/auto/render/qbuffer/tst_qbuffer.cpp b/tests/auto/render/qbuffer/tst_qbuffer.cpp
index 6ebe841ea..20dcc28ba 100644
--- a/tests/auto/render/qbuffer/tst_qbuffer.cpp
+++ b/tests/auto/render/qbuffer/tst_qbuffer.cpp
@@ -119,7 +119,7 @@ void TestPostman::notifyBackend(const Qt3D::QSceneChangePtr &e)
     m_arbiter->sceneChangeEventWithLock(e);
 }
 
-class TestFunctor : public Qt3D::QBufferFunctor
+class TestFunctor : public Qt3DRender::QBufferFunctor
 {
 public:
     explicit TestFunctor(int size)
@@ -131,7 +131,7 @@ public:
         return QByteArray();
     }
 
-    bool operator ==(const Qt3D::QBufferFunctor &other) const
+    bool operator ==(const Qt3DRender::QBufferFunctor &other) const
     {
         const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other);
         if (otherFunctor != Q_NULLPTR)
@@ -160,31 +160,31 @@ private Q_SLOTS:
 
     void checkCloning_data()
     {
-        QTest::addColumn<Qt3D::QBuffer *>("buffer");
+        QTest::addColumn<Qt3DRender::QBuffer *>("buffer");
 
-        Qt3D::QBuffer *defaultConstructed = new Qt3D::QBuffer();
+        Qt3DRender::QBuffer *defaultConstructed = new Qt3DRender::QBuffer();
         QTest::newRow("defaultConstructed") << defaultConstructed;
 
-        Qt3D::QBuffer *buffer = new Qt3D::QBuffer(Qt3D::QBuffer::VertexBuffer);
-        buffer->setUsage(Qt3D::QBuffer::DynamicRead);
+        Qt3DRender::QBuffer *buffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::VertexBuffer);
+        buffer->setUsage(Qt3DRender::QBuffer::DynamicRead);
         buffer->setData(QByteArrayLiteral("There's no replacement"));
-        buffer->setBufferFunctor(Qt3D::QBufferFunctorPtr(new TestFunctor(883)));
+        buffer->setBufferFunctor(Qt3DRender::QBufferFunctorPtr(new TestFunctor(883)));
         QTest::newRow("vertex") << buffer;
 
-        Qt3D::QBuffer *indexBuffer = new Qt3D::QBuffer(Qt3D::QBuffer::IndexBuffer);
-        indexBuffer->setUsage(Qt3D::QBuffer::StaticCopy);
+        Qt3DRender::QBuffer *indexBuffer = new Qt3DRender::QBuffer(Qt3DRender::QBuffer::IndexBuffer);
+        indexBuffer->setUsage(Qt3DRender::QBuffer::StaticCopy);
         indexBuffer->setData(QByteArrayLiteral("For displacement"));
-        indexBuffer->setBufferFunctor(Qt3D::QBufferFunctorPtr(new TestFunctor(1340)));
+        indexBuffer->setBufferFunctor(Qt3DRender::QBufferFunctorPtr(new TestFunctor(1340)));
         QTest::newRow("index") << indexBuffer;
     }
 
     void checkCloning()
     {
         // GIVEN
-        QFETCH(Qt3D::QBuffer *, buffer);
+        QFETCH(Qt3DRender::QBuffer *, buffer);
 
         // WHEN
-        Qt3D::QBuffer *clone = static_cast<Qt3D::QBuffer *>(QNode::clone(buffer));
+        Qt3DRender::QBuffer *clone = static_cast<Qt3DRender::QBuffer *>(QNode::clone(buffer));
 
         // THEN
         QVERIFY(clone != Q_NULLPTR);
@@ -203,30 +203,30 @@ private Q_SLOTS:
     void checkPropertyUpdates()
     {
         // GIVEN
-        QScopedPointer<Qt3D::QBuffer> buffer(new Qt3D::QBuffer(Qt3D::QBuffer::VertexBuffer));
+        QScopedPointer<Qt3DRender::QBuffer> buffer(new Qt3DRender::QBuffer(Qt3DRender::QBuffer::VertexBuffer));
         TestArbiter arbiter(buffer.data());
 
         // WHEN
-        buffer->setType(Qt3D::QBuffer::IndexBuffer);
+        buffer->setType(Qt3DRender::QBuffer::IndexBuffer);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
         Qt3D::QScenePropertyChangePtr change = arbiter.events.first().staticCast<Qt3D::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "type");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3D::QBuffer::IndexBuffer));
+        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QBuffer::IndexBuffer));
 
         arbiter.events.clear();
 
         // WHEN
-        buffer->setUsage(Qt3D::QBuffer::DynamicCopy);
+        buffer->setUsage(Qt3DRender::QBuffer::DynamicCopy);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
         change = arbiter.events.first().staticCast<Qt3D::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "usage");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3D::QBuffer::DynamicCopy));
+        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QBuffer::DynamicCopy));
 
         arbiter.events.clear();
 
@@ -243,7 +243,7 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN
-        Qt3D::QBufferFunctorPtr functor(new TestFunctor(355));
+        Qt3DRender::QBufferFunctorPtr functor(new TestFunctor(355));
         buffer->setBufferFunctor(functor);
         QCoreApplication::processEvents();
 
@@ -251,7 +251,7 @@ private Q_SLOTS:
         QCOMPARE(arbiter.events.size(), 1);
         change = arbiter.events.first().staticCast<Qt3D::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "bufferFunctor");
-        QCOMPARE(change->value().value<Qt3D::QBufferFunctorPtr>(), functor);
+        QCOMPARE(change->value().value<Qt3DRender::QBufferFunctorPtr>(), functor);
 
         arbiter.events.clear();
     }
diff --git a/tests/auto/render/qgeometry/tst_qgeometry.cpp b/tests/auto/render/qgeometry/tst_qgeometry.cpp
index d7fb2c3de..00c44d953 100644
--- a/tests/auto/render/qgeometry/tst_qgeometry.cpp
+++ b/tests/auto/render/qgeometry/tst_qgeometry.cpp
@@ -135,24 +135,24 @@ private Q_SLOTS:
 
     void checkCloning_data()
     {
-        QTest::addColumn<Qt3D::QGeometry *>("geometry");
+        QTest::addColumn<Qt3DRender::QGeometry *>("geometry");
         QTest::addColumn<int>("attributeCount");
 
-        Qt3D::QGeometry *defaultConstructed = new Qt3D::QGeometry();
+        Qt3DRender::QGeometry *defaultConstructed = new Qt3DRender::QGeometry();
         QTest::newRow("defaultConstructed") << defaultConstructed << 0;
 
-        Qt3D::QGeometry *geometry1 = new Qt3D::QGeometry();
+        Qt3DRender::QGeometry *geometry1 = new Qt3DRender::QGeometry();
         geometry1->setVerticesPerPatch(2);
-        geometry1->addAttribute(new Qt3D::QAttribute(Q_NULLPTR, QStringLiteral("Attr1"), Qt3D::QAttribute::Float, 3, 454));
-        geometry1->addAttribute(new Qt3D::QAttribute(Q_NULLPTR, QStringLiteral("Attr2"), Qt3D::QAttribute::Float, 4, 555));
+        geometry1->addAttribute(new Qt3DRender::QAttribute(Q_NULLPTR, QStringLiteral("Attr1"), Qt3DRender::QAttribute::Float, 3, 454));
+        geometry1->addAttribute(new Qt3DRender::QAttribute(Q_NULLPTR, QStringLiteral("Attr2"), Qt3DRender::QAttribute::Float, 4, 555));
         QTest::newRow("2 attributes") << geometry1 << 2;
 
 
-        Qt3D::QGeometry *geometry2 = new Qt3D::QGeometry();
-        Qt3D::QAttribute *attribute = new Qt3D::QAttribute(Q_NULLPTR, QStringLiteral("Attr2"), Qt3D::QAttribute::Float, 4, 383);
-        geometry2->addAttribute(new Qt3D::QAttribute(Q_NULLPTR, QStringLiteral("Attr1"), Qt3D::QAttribute::Float, 3, 427));
+        Qt3DRender::QGeometry *geometry2 = new Qt3DRender::QGeometry();
+        Qt3DRender::QAttribute *attribute = new Qt3DRender::QAttribute(Q_NULLPTR, QStringLiteral("Attr2"), Qt3DRender::QAttribute::Float, 4, 383);
+        geometry2->addAttribute(new Qt3DRender::QAttribute(Q_NULLPTR, QStringLiteral("Attr1"), Qt3DRender::QAttribute::Float, 3, 427));
         geometry2->addAttribute(attribute);
-        geometry2->addAttribute(new Qt3D::QAttribute(Q_NULLPTR, QStringLiteral("Attr3"), Qt3D::QAttribute::Float, 2, 327));
+        geometry2->addAttribute(new Qt3DRender::QAttribute(Q_NULLPTR, QStringLiteral("Attr3"), Qt3DRender::QAttribute::Float, 2, 327));
         geometry2->removeAttribute(attribute);
         geometry2->setVerticesPerPatch(3);
         QTest::newRow("3 - 1 attributes") << geometry2 << 2;
@@ -161,11 +161,11 @@ private Q_SLOTS:
     void checkCloning()
     {
         // GIVEN
-        QFETCH(Qt3D::QGeometry *, geometry);
+        QFETCH(Qt3DRender::QGeometry *, geometry);
         QFETCH(int, attributeCount);
 
         // WHEN
-        Qt3D::QGeometry *clone = static_cast<Qt3D::QGeometry *>(QNode::clone(geometry));
+        Qt3DRender::QGeometry *clone = static_cast<Qt3DRender::QGeometry *>(QNode::clone(geometry));
 
         // THEN
         QVERIFY(clone != Q_NULLPTR);
@@ -176,8 +176,8 @@ private Q_SLOTS:
         QCOMPARE(geometry->verticesPerPatch(), clone->verticesPerPatch());
 
         for (int i = 0; i < attributeCount; ++i) {
-            Qt3D::QAttribute *originalAttribute = static_cast<Qt3D::QAttribute *>(geometry->attributes()[i]);
-            Qt3D::QAttribute *cloneAttribute = static_cast<Qt3D::QAttribute *>(clone->attributes()[i]);
+            Qt3DRender::QAttribute *originalAttribute = static_cast<Qt3DRender::QAttribute *>(geometry->attributes()[i]);
+            Qt3DRender::QAttribute *cloneAttribute = static_cast<Qt3DRender::QAttribute *>(clone->attributes()[i]);
 
             QCOMPARE(originalAttribute->id(), cloneAttribute->id());
             QCOMPARE(originalAttribute->name(), cloneAttribute->name());
@@ -193,11 +193,11 @@ private Q_SLOTS:
     void checkPropertyUpdates()
     {
         // GIVEN
-        QScopedPointer<Qt3D::QGeometry> geometry(new Qt3D::QGeometry());
+        QScopedPointer<Qt3DRender::QGeometry> geometry(new Qt3DRender::QGeometry());
         TestArbiter arbiter(geometry.data());
 
         // WHEN
-        Qt3D::QAttribute attr;
+        Qt3DRender::QAttribute attr;
         geometry->addAttribute(&attr);
         QCoreApplication::processEvents();
 
diff --git a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
index b5e8c5592..291a767d4 100644
--- a/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
+++ b/tests/auto/render/qgeometryrenderer/tst_qgeometryrenderer.cpp
@@ -122,19 +122,19 @@ void TestPostman::notifyBackend(const Qt3D::QSceneChangePtr &e)
     m_arbiter->sceneChangeEventWithLock(e);
 }
 
-class TestFunctor : public Qt3D::QGeometryFunctor
+class TestFunctor : public Qt3DRender::QGeometryFunctor
 {
 public:
     explicit TestFunctor(int size)
         : m_size(size)
     {}
 
-    Qt3D::QGeometry *operator ()() Q_DECL_FINAL
+    Qt3DRender::QGeometry *operator ()() Q_DECL_FINAL
     {
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3D::QGeometryFunctor &other) const
+    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const
     {
         const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other);
         if (otherFunctor != Q_NULLPTR)
@@ -163,43 +163,43 @@ private Q_SLOTS:
 
     void checkCloning_data()
     {
-        QTest::addColumn<Qt3D::QGeometryRenderer *>("geometryRenderer");
+        QTest::addColumn<Qt3DRender::QGeometryRenderer *>("geometryRenderer");
 
-        Qt3D::QGeometryRenderer *defaultConstructed = new Qt3D::QGeometryRenderer();
+        Qt3DRender::QGeometryRenderer *defaultConstructed = new Qt3DRender::QGeometryRenderer();
         QTest::newRow("defaultConstructed") << defaultConstructed ;
 
-        Qt3D::QGeometryRenderer *geometry1 = new Qt3D::QGeometryRenderer();
-        geometry1->setGeometry(new Qt3D::QGeometry());
+        Qt3DRender::QGeometryRenderer *geometry1 = new Qt3DRender::QGeometryRenderer();
+        geometry1->setGeometry(new Qt3DRender::QGeometry());
         geometry1->setInstanceCount(1);
         geometry1->setBaseVertex(0);
         geometry1->setBaseInstance(55);
         geometry1->setRestartIndex(-1);
         geometry1->setPrimitiveRestart(false);
-        geometry1->setPrimitiveType(Qt3D::QGeometryRenderer::Triangles);
+        geometry1->setPrimitiveType(Qt3DRender::QGeometryRenderer::Triangles);
         geometry1->setPrimitiveCount(15);
-        geometry1->setGeometryFunctor(Qt3D::QGeometryFunctorPtr(new TestFunctor(383)));
+        geometry1->setGeometryFunctor(Qt3DRender::QGeometryFunctorPtr(new TestFunctor(383)));
         QTest::newRow("triangle") << geometry1;
 
-        Qt3D::QGeometryRenderer *geometry2 = new Qt3D::QGeometryRenderer();
-        geometry2->setGeometry(new Qt3D::QGeometry());
+        Qt3DRender::QGeometryRenderer *geometry2 = new Qt3DRender::QGeometryRenderer();
+        geometry2->setGeometry(new Qt3DRender::QGeometry());
         geometry2->setInstanceCount(200);
         geometry2->setBaseVertex(58);
         geometry2->setBaseInstance(10);
         geometry2->setRestartIndex(65535);
         geometry1->setPrimitiveCount(2056);
         geometry2->setPrimitiveRestart(true);
-        geometry2->setPrimitiveType(Qt3D::QGeometryRenderer::Lines);
-        geometry2->setGeometryFunctor(Qt3D::QGeometryFunctorPtr(new TestFunctor(305)));
+        geometry2->setPrimitiveType(Qt3DRender::QGeometryRenderer::Lines);
+        geometry2->setGeometryFunctor(Qt3DRender::QGeometryFunctorPtr(new TestFunctor(305)));
         QTest::newRow("lines with restart") << geometry2;
     }
 
     void checkCloning()
     {
         // GIVEN
-        QFETCH(Qt3D::QGeometryRenderer *, geometryRenderer);
+        QFETCH(Qt3DRender::QGeometryRenderer *, geometryRenderer);
 
         // WHEN
-        Qt3D::QGeometryRenderer *clone = static_cast<Qt3D::QGeometryRenderer *>(QNode::clone(geometryRenderer));
+        Qt3DRender::QGeometryRenderer *clone = static_cast<Qt3DRender::QGeometryRenderer *>(QNode::clone(geometryRenderer));
 
         // THEN
         QVERIFY(clone != Q_NULLPTR);
@@ -228,7 +228,7 @@ private Q_SLOTS:
     void checkPropertyUpdates()
     {
         // GIVEN
-        QScopedPointer<Qt3D::QGeometryRenderer> geometryRenderer(new Qt3D::QGeometryRenderer());
+        QScopedPointer<Qt3DRender::QGeometryRenderer> geometryRenderer(new Qt3DRender::QGeometryRenderer());
         TestArbiter arbiter(geometryRenderer.data());
 
         // WHEN
@@ -310,20 +310,20 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN
-        geometryRenderer->setPrimitiveType(Qt3D::QGeometryRenderer::Patches);
+        geometryRenderer->setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
         QCoreApplication::processEvents();
 
         // THEN
         QCOMPARE(arbiter.events.size(), 1);
         change = arbiter.events.first().staticCast<Qt3D::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "primitiveType");
-        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3D::QGeometryRenderer::Patches));
+        QCOMPARE(change->value().value<int>(), static_cast<int>(Qt3DRender::QGeometryRenderer::Patches));
         QCOMPARE(change->type(), Qt3D::NodeUpdated);
 
         arbiter.events.clear();
 
         // WHEN
-        Qt3D::QGeometryFunctorPtr functor(new TestFunctor(555));
+        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(555));
         geometryRenderer->setGeometryFunctor(functor);
         QCoreApplication::processEvents();
 
@@ -331,13 +331,13 @@ private Q_SLOTS:
         QCOMPARE(arbiter.events.size(), 1);
         change = arbiter.events.first().staticCast<Qt3D::QScenePropertyChange>();
         QCOMPARE(change->propertyName(), "geometryFunctor");
-        QCOMPARE(change->value().value<Qt3D::QGeometryFunctorPtr>(), functor);
+        QCOMPARE(change->value().value<Qt3DRender::QGeometryFunctorPtr>(), functor);
         QCOMPARE(change->type(), Qt3D::NodeUpdated);
 
         arbiter.events.clear();
 
         // WHEN
-        Qt3D::QGeometry geom;
+        Qt3DRender::QGeometry geom;
         geometryRenderer->setGeometry(&geom);
         QCoreApplication::processEvents();
 
@@ -351,7 +351,7 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN
-        Qt3D::QGeometry geom2;
+        Qt3DRender::QGeometry geom2;
         geometryRenderer->setGeometry(&geom2);
         QCoreApplication::processEvents();
 
diff --git a/tests/auto/render/qgraphicsutils/tst_qgraphicsutils.cpp b/tests/auto/render/qgraphicsutils/tst_qgraphicsutils.cpp
index 6ca270a2b..c1cff2511 100644
--- a/tests/auto/render/qgraphicsutils/tst_qgraphicsutils.cpp
+++ b/tests/auto/render/qgraphicsutils/tst_qgraphicsutils.cpp
@@ -52,14 +52,14 @@ private slots:
 
 void tst_QGraphicsUtils::fillScalarInDataArray()
 {
-    Qt3D::Render::ShaderUniform description;
+    Qt3DRender::Render::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 0;
     description.m_arrayStride = 10;
 
     QVector4D testVector(8.0f, 8.0f, 3.0f, 1.0f);
-    const GLfloat *vectorData = Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(testVector, 1, 4);
+    const GLfloat *vectorData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(testVector, 1, 4);
 
     for (int i = 0; i < 4; i++) {
         if (i == 0)
@@ -76,7 +76,7 @@ void tst_QGraphicsUtils::fillScalarInDataArray()
     char *innerData = data.data();
 
     // Checked that we are not overflowing
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 2);
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 2);
     for (int i = 0; i < 4; ++i) {
         if (i < 2)
             QVERIFY(vectorData[i] == ((GLfloat*)innerData)[i]);
@@ -85,7 +85,7 @@ void tst_QGraphicsUtils::fillScalarInDataArray()
     }
 
     // Check that all values are copied
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
     for (int i = 0; i < 4; ++i)
         QVERIFY(vectorData[i] == ((GLfloat*)innerData)[i]);
 
@@ -94,7 +94,7 @@ void tst_QGraphicsUtils::fillScalarInDataArray()
     data = QByteArray(description.m_size * 8 * sizeof(GLfloat), 0);
     innerData = data.data();
 
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
     for (int i = 0; i < 8; ++i) {
         if (i < 4)
             QVERIFY(((GLfloat*)innerData)[i] == 0.0f);
@@ -110,9 +110,9 @@ void tst_QGraphicsUtils::fillArray()
     QVector4D testVector3(4.0f, 5.0f, 4.0f, 2.0f);
 
     QVariantList variantList = QVariantList() << testVector << testVector2 << testVector3;
-    const GLfloat *vectorData = Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant(variantList), 3, 4);
+    const GLfloat *vectorData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant(variantList), 3, 4);
 
-    Qt3D::Render::ShaderUniform description;
+    Qt3DRender::Render::ShaderUniform description;
 
     description.m_size = 3;
     description.m_offset = 16;
@@ -120,7 +120,7 @@ void tst_QGraphicsUtils::fillArray()
 
     QByteArray data(description.m_size * (4 + description.m_arrayStride) * sizeof(GLfloat) + description.m_offset, 0);
     char *innerData = data.data();
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData, vectorData, description, 4);
 
     int offset = description.m_offset / sizeof(GLfloat);
     int stride = description.m_arrayStride / sizeof(GLfloat);
@@ -152,25 +152,25 @@ void tst_QGraphicsUtils::fillScalarWithOffsets()
     QVector4D color(4.0f, 5.0f, 4.0f, 1.0f);
     float intensity = 1.0f;
 
-    Qt3D::Render::ShaderUniform posUniform;
+    Qt3DRender::Render::ShaderUniform posUniform;
     posUniform.m_size = 1;
     posUniform.m_arrayStride = 0;
     posUniform.m_matrixStride = 0;
     posUniform.m_offset = 0;
 
-    Qt3D::Render::ShaderUniform dirUniform;
+    Qt3DRender::Render::ShaderUniform dirUniform;
     dirUniform.m_size = 1;
     dirUniform.m_arrayStride = 0;
     dirUniform.m_matrixStride = 0;
     dirUniform.m_offset = 16;
 
-    Qt3D::Render::ShaderUniform colUniform;
+    Qt3DRender::Render::ShaderUniform colUniform;
     colUniform.m_size = 1;
     colUniform.m_arrayStride = 0;
     colUniform.m_matrixStride = 0;
     colUniform.m_offset = 32;
 
-    Qt3D::Render::ShaderUniform intUniform;
+    Qt3DRender::Render::ShaderUniform intUniform;
     intUniform.m_size = 1;
     intUniform.m_arrayStride = 0;
     intUniform.m_matrixStride = 0;
@@ -179,17 +179,17 @@ void tst_QGraphicsUtils::fillScalarWithOffsets()
     QVector<GLfloat> data(16);
     void *innerData = data.data();
 
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(position, 1, 3),
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
+                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(position, 1, 3),
                                                 posUniform, 3);
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(direction, 1, 3),
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
+                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(direction, 1, 3),
                                                 dirUniform, 3);
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(color, 1, 4),
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
+                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(color, 1, 4),
                                                 colUniform, 4);
-    Qt3D::Render::QGraphicsUtils::fillDataArray(innerData,
-                                                Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(intensity, 1, 1),
+    Qt3DRender::Render::QGraphicsUtils::fillDataArray(innerData,
+                                                Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(intensity, 1, 1),
                                                 intUniform, 1);
 
     GLfloat *floatData = (GLfloat*)innerData;
@@ -222,9 +222,9 @@ void tst_QGraphicsUtils::fillMatrix4x4()
     QMatrix4x4 mat(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f);
 
     // column major
-    const GLfloat *matData = Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(mat, 1, 16);
+    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(mat, 1, 16);
 
-    Qt3D::Render::ShaderUniform description;
+    Qt3DRender::Render::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 0;
@@ -234,7 +234,7 @@ void tst_QGraphicsUtils::fillMatrix4x4()
 
     QByteArray data(description.m_size * 16 * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3D::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
+    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
     // Check for no offset/no stride
     for (int i = 0; i < 16; ++i)
         QVERIFY((((GLfloat *)innerData)[i]) == matData[i]);
@@ -242,7 +242,7 @@ void tst_QGraphicsUtils::fillMatrix4x4()
     description.m_offset = 12;
     data = QByteArray((description.m_size * 16  + description.m_offset) * sizeof(GLfloat), 0);
     innerData = data.data();
-    Qt3D::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
+    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
     // Check with 12 offset/no stride
     for (int i = 0; i < 16; ++i)
         QVERIFY((((GLfloat *)innerData)[3 + i]) == matData[i]);
@@ -250,7 +250,7 @@ void tst_QGraphicsUtils::fillMatrix4x4()
     description.m_matrixStride = 16;
     data = QByteArray((description.m_size * 16 + 4 * description.m_matrixStride + description.m_offset) * sizeof(GLfloat), 0);
     innerData = data.data();
-    Qt3D::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
+    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 4);
     // Check with 10 offset/ 16 stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
@@ -267,9 +267,9 @@ void tst_QGraphicsUtils::fillMatrix3x4()
     QMatrix3x4 mat;
 
     mat.fill(6.0f);
-    const GLfloat *matData = Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
+    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
 
-    Qt3D::Render::ShaderUniform description;
+    Qt3DRender::Render::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 16;
@@ -278,7 +278,7 @@ void tst_QGraphicsUtils::fillMatrix3x4()
 
     QByteArray data((description.m_size * 12 + 3 * description.m_matrixStride + description.m_offset) * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3D::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 3, 4);
+    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 3, 4);
     // Check with 16 offset/ 12 stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
@@ -295,9 +295,9 @@ void tst_QGraphicsUtils::fillMatrix4x3()
     QMatrix4x3 mat;
 
     mat.fill(6.0f);
-    const GLfloat *matData = Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
+    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(mat), 1, 12);
 
-    Qt3D::Render::ShaderUniform description;
+    Qt3DRender::Render::ShaderUniform description;
 
     description.m_size = 1;
     description.m_offset = 16;
@@ -306,7 +306,7 @@ void tst_QGraphicsUtils::fillMatrix4x3()
 
     QByteArray data((description.m_size * 12 + 4 * description.m_matrixStride + description.m_offset) * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3D::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
+    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
     // Check with 16 offset/ 16 stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
@@ -329,9 +329,9 @@ void tst_QGraphicsUtils::fillMatrixArray()
 
     QVariantList matrices = QVariantList() << QVariant::fromValue(mat1) << QVariant::fromValue(mat2) << QVariant::fromValue(mat3);
 
-    const GLfloat *matData = Qt3D::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(matrices), 3, 12);
+    const GLfloat *matData = Qt3DRender::Render::QGraphicsUtils::valueArrayFromVariant<GLfloat>(QVariant::fromValue(matrices), 3, 12);
 
-    Qt3D::Render::ShaderUniform description;
+    Qt3DRender::Render::ShaderUniform description;
 
     description.m_size = 3;
     description.m_offset = 12;
@@ -340,7 +340,7 @@ void tst_QGraphicsUtils::fillMatrixArray()
 
     QByteArray data((description.m_size * (12 + 4 * description.m_matrixStride + description.m_arrayStride) + description.m_offset) * sizeof(GLfloat), 0);
     char *innerData = data.data();
-    Qt3D::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
+    Qt3DRender::Render::QGraphicsUtils::fillDataMatrixArray(innerData, matData, description, 4, 3);
     // Check with 12 offset/ 4 array stride / 16 matrix stride
     int offset = description.m_offset / sizeof(GLfloat);
     int matrixStride = description.m_matrixStride / sizeof(GLfloat);
diff --git a/tests/auto/render/qmaterial/tst_qmaterial.cpp b/tests/auto/render/qmaterial/tst_qmaterial.cpp
index 682a73d2f..01bd361b1 100644
--- a/tests/auto/render/qmaterial/tst_qmaterial.cpp
+++ b/tests/auto/render/qmaterial/tst_qmaterial.cpp
@@ -55,15 +55,15 @@
 #include <Qt3DRenderer/QNormalDiffuseMapAlphaMaterial>
 #include <Qt3DRenderer/QNormalDiffuseSpecularMapMaterial>
 
-class TestMaterial : public Qt3D::QMaterial
+class TestMaterial : public Qt3DRender::QMaterial
 {
 public:
     explicit TestMaterial(Qt3D::QNode *parent = 0)
-        : Qt3D::QMaterial(parent)
-        , m_effect(new Qt3D::QEffect(this))
-        , m_technique(new Qt3D::QTechnique(this))
-        , m_renderPass(new Qt3D::QRenderPass(this))
-        , m_shaderProgram(new Qt3D::QShaderProgram(this))
+        : Qt3DRender::QMaterial(parent)
+        , m_effect(new Qt3DRender::QEffect(this))
+        , m_technique(new Qt3DRender::QTechnique(this))
+        , m_renderPass(new Qt3DRender::QRenderPass(this))
+        , m_shaderProgram(new Qt3DRender::QShaderProgram(this))
     {
         m_renderPass->setShaderProgram(m_shaderProgram);
         m_technique->addPass(m_renderPass);
@@ -76,10 +76,10 @@ public:
         QNode::cleanup();
     }
 
-    Qt3D::QEffect *m_effect;
-    Qt3D::QTechnique *m_technique;
-    Qt3D::QRenderPass *m_renderPass;
-    Qt3D::QShaderProgram *m_shaderProgram;
+    Qt3DRender::QEffect *m_effect;
+    Qt3DRender::QTechnique *m_technique;
+    Qt3DRender::QRenderPass *m_renderPass;
+    Qt3DRender::QShaderProgram *m_shaderProgram;
 };
 
 class TestArbiter;
@@ -170,7 +170,7 @@ public:
 
 private:
 
-    void compareEffects(const Qt3D::QEffect *original, const Qt3D::QEffect *clone)
+    void compareEffects(const Qt3DRender::QEffect *original, const Qt3DRender::QEffect *clone)
     {
         bool isEffectNull = (original == Q_NULLPTR);
         if (isEffectNull) {
@@ -189,7 +189,7 @@ private:
         }
     }
 
-    void compareTechniques(const Qt3D::QTechnique *original, const Qt3D::QTechnique *clone)
+    void compareTechniques(const Qt3DRender::QTechnique *original, const Qt3DRender::QTechnique *clone)
     {
         QCOMPARE(original->id(), clone->id());
 
@@ -202,7 +202,7 @@ private:
             compareRenderPasses(original->renderPasses().at(i), clone->renderPasses().at(i));
     }
 
-    void compareRenderPasses(const Qt3D::QRenderPass *original, const Qt3D::QRenderPass *clone)
+    void compareRenderPasses(const Qt3DRender::QRenderPass *original, const Qt3DRender::QRenderPass *clone)
     {
         QCOMPARE(original->id(), clone->id());
 
@@ -213,41 +213,41 @@ private:
         compareShaderPrograms(original->shaderProgram(), clone->shaderProgram());
     }
 
-    void compareParameters(const Qt3D::ParameterList &original, const Qt3D::ParameterList &clone)
+    void compareParameters(const Qt3DRender::ParameterList &original, const Qt3DRender::ParameterList &clone)
     {
         QCOMPARE(original.size(), clone.size());
         const int parametersCount = original.size();
         for (int i = 0; i < parametersCount; ++i) {
-            const Qt3D::QParameter *originParam = original.at(i);
-            const Qt3D::QParameter *cloneParam = clone.at(i);
+            const Qt3DRender::QParameter *originParam = original.at(i);
+            const Qt3DRender::QParameter *cloneParam = clone.at(i);
             QCOMPARE(originParam->id(), cloneParam->id());
             QCOMPARE(cloneParam->name(), originParam->name());
             QCOMPARE(cloneParam->value(), originParam->value());
         }
     }
 
-    void compareAnnotations(const QList<Qt3D::QAnnotation *> &original, const QList<Qt3D::QAnnotation *> &clone)
+    void compareAnnotations(const QList<Qt3DRender::QAnnotation *> &original, const QList<Qt3DRender::QAnnotation *> &clone)
     {
         const int annotationsCount = original.size();
         QCOMPARE(annotationsCount, clone.size());
 
         for (int i = 0; i < annotationsCount; ++i) {
-            const Qt3D::QAnnotation *origAnnotation = original.at(i);
-            const Qt3D::QAnnotation *cloneAnnotation = clone.at(i);
+            const Qt3DRender::QAnnotation *origAnnotation = original.at(i);
+            const Qt3DRender::QAnnotation *cloneAnnotation = clone.at(i);
             QCOMPARE(origAnnotation->id(), cloneAnnotation->id());
             QCOMPARE(origAnnotation->name(), cloneAnnotation->name());
             QCOMPARE(origAnnotation->value(), cloneAnnotation->value());
         }
     }
 
-    void compareBindings(const QList<Qt3D::QParameterMapping *> &original, const QList<Qt3D::QParameterMapping *> &clone)
+    void compareBindings(const QList<Qt3DRender::QParameterMapping *> &original, const QList<Qt3DRender::QParameterMapping *> &clone)
     {
         const int bindingsCount = original.size();
         QCOMPARE(bindingsCount, clone.size());
 
         for (int i = 0; i < bindingsCount; ++i) {
-            const Qt3D::QParameterMapping *origMapping = original.at(i);
-            const Qt3D::QParameterMapping *cloneMapping = clone.at(i);
+            const Qt3DRender::QParameterMapping *origMapping = original.at(i);
+            const Qt3DRender::QParameterMapping *cloneMapping = clone.at(i);
 
             QCOMPARE(origMapping->id(), cloneMapping->id());
             QCOMPARE(origMapping->bindingType(), cloneMapping->bindingType());
@@ -256,20 +256,20 @@ private:
         }
     }
 
-    void compareRenderStates(const QList<Qt3D::QRenderState *> &original, const QList<Qt3D::QRenderState *> &clone)
+    void compareRenderStates(const QList<Qt3DRender::QRenderState *> &original, const QList<Qt3DRender::QRenderState *> &clone)
     {
         const int renderStatesCount = original.size();
         QCOMPARE(renderStatesCount, clone.size());
 
         for (int i = 0; i < renderStatesCount; ++i) {
-            const Qt3D::QRenderState *originState = original.at(i);
-            const Qt3D::QRenderState *cloneState = clone.at(i);
+            const Qt3DRender::QRenderState *originState = original.at(i);
+            const Qt3DRender::QRenderState *cloneState = clone.at(i);
             QCOMPARE(originState->id(), originState->id());
             QVERIFY(originState->type() == cloneState->type());
         }
     }
 
-    void compareShaderPrograms(const Qt3D::QShaderProgram *original, const Qt3D::QShaderProgram *clone)
+    void compareShaderPrograms(const Qt3DRender::QShaderProgram *original, const Qt3DRender::QShaderProgram *clone)
     {
         bool isOriginalNull = (original == Q_NULLPTR);
         if (isOriginalNull) {
@@ -290,35 +290,35 @@ private Q_SLOTS:
 
     void checkCloning_data()
     {
-        QTest::addColumn<Qt3D::QMaterial *>("material");
+        QTest::addColumn<Qt3DRender::QMaterial *>("material");
 
-        Qt3D::QMaterial *material = new Qt3D::QMaterial();
+        Qt3DRender::QMaterial *material = new Qt3DRender::QMaterial();
         QTest::newRow("empty material") << material;
         material = new TestMaterial();
         QTest::newRow("test material") << material;
-        material = new Qt3D::QPhongMaterial();
+        material = new Qt3DRender::QPhongMaterial();
         QTest::newRow("QPhongMaterial") << material;
-        material = new Qt3D::QDiffuseMapMaterial();
+        material = new Qt3DRender::QDiffuseMapMaterial();
         QTest::newRow("QDiffuseMapMaterial") << material;
-        material = new Qt3D::QDiffuseSpecularMapMaterial();
+        material = new Qt3DRender::QDiffuseSpecularMapMaterial();
         QTest::newRow("QDiffuseMapSpecularMaterial") << material;
-        material = new Qt3D::QPerVertexColorMaterial();
+        material = new Qt3DRender::QPerVertexColorMaterial();
         QTest::newRow("QPerVertexColorMaterial") << material;
-        material = new Qt3D::QNormalDiffuseMapMaterial();
+        material = new Qt3DRender::QNormalDiffuseMapMaterial();
         QTest::newRow("QNormalDiffuseMapMaterial") << material;
-        material = new Qt3D::QNormalDiffuseMapAlphaMaterial();
+        material = new Qt3DRender::QNormalDiffuseMapAlphaMaterial();
         QTest::newRow("QNormalDiffuseMapAlphaMaterial") << material;
-        material = new Qt3D::QNormalDiffuseSpecularMapMaterial();
+        material = new Qt3DRender::QNormalDiffuseSpecularMapMaterial();
         QTest::newRow("QNormalDiffuseSpecularMapMaterial") << material;
     }
 
     void checkCloning()
     {
         // GIVEN
-        QFETCH(Qt3D::QMaterial *, material);
+        QFETCH(Qt3DRender::QMaterial *, material);
 
         // WHEN
-        Qt3D::QMaterial *clone = static_cast<Qt3D::QMaterial *>(QNode::clone(material));
+        Qt3DRender::QMaterial *clone = static_cast<Qt3DRender::QMaterial *>(QNode::clone(material));
         QCoreApplication::processEvents();
 
         // THEN
@@ -330,11 +330,11 @@ private Q_SLOTS:
     void checkEffectUpdate()
     {
         // GIVEN
-        QScopedPointer<Qt3D::QMaterial> material(new Qt3D::QMaterial());
+        QScopedPointer<Qt3DRender::QMaterial> material(new Qt3DRender::QMaterial());
         TestArbiter arbiter(material.data());
 
         // WHEN
-        Qt3D::QEffect effect;
+        Qt3DRender::QEffect effect;
         material->setEffect(&effect);
         QCoreApplication::processEvents();
 
@@ -352,7 +352,7 @@ private Q_SLOTS:
         TestArbiter arbiter2(material2.data());
 
         // WHEN
-        Qt3D::QEffect *oldEffect = material2->effect();
+        Qt3DRender::QEffect *oldEffect = material2->effect();
         material2->setEffect(&effect);
         QCoreApplication::processEvents();
 
@@ -376,7 +376,7 @@ private Q_SLOTS:
         TestArbiter arbiter(material);
 
         // WHEN (add parameter to material)
-        Qt3D::QParameter *param = new Qt3D::QParameter("testParamMaterial", QVariant::fromValue(383.0f));
+        Qt3DRender::QParameter *param = new Qt3DRender::QParameter("testParamMaterial", QVariant::fromValue(383.0f));
         material->addParameter(param);
         QCoreApplication::processEvents();
 
@@ -390,7 +390,7 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN (add parameter to effect)
-        param = new Qt3D::QParameter("testParamEffect", QVariant::fromValue(383.0f));
+        param = new Qt3DRender::QParameter("testParamEffect", QVariant::fromValue(383.0f));
         material->effect()->addParameter(param);
         QCoreApplication::processEvents();
 
@@ -404,7 +404,7 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN (add parameter to technique)
-        param = new Qt3D::QParameter("testParamTechnique", QVariant::fromValue(383.0f));
+        param = new Qt3DRender::QParameter("testParamTechnique", QVariant::fromValue(383.0f));
         material->m_technique->addParameter(param);
         QCoreApplication::processEvents();
 
@@ -418,7 +418,7 @@ private Q_SLOTS:
         arbiter.events.clear();
 
         // WHEN (add parameter to renderpass)
-        param = new Qt3D::QParameter("testParamRenderPass", QVariant::fromValue(383.0f));
+        param = new Qt3DRender::QParameter("testParamRenderPass", QVariant::fromValue(383.0f));
         material->m_renderPass->addParameter(param);
         QCoreApplication::processEvents();
 
diff --git a/tests/auto/render/raycasting/tst_raycasting.cpp b/tests/auto/render/raycasting/tst_raycasting.cpp
index a41f6c9a1..84be49fee 100644
--- a/tests/auto/render/raycasting/tst_raycasting.cpp
+++ b/tests/auto/render/raycasting/tst_raycasting.cpp
@@ -42,7 +42,8 @@
 #include <Qt3DCore/qray3d.h>
 
 using namespace Qt3D;
-using namespace Qt3D::Render;
+using namespace Qt3DRender;
+using namespace Qt3DRender::Render;
 
 class tst_RayCasting : public QObject
 {
diff --git a/tests/auto/render/renderattribute/tst_renderattribute.cpp b/tests/auto/render/renderattribute/tst_renderattribute.cpp
index bbf800e42..892a33a38 100644
--- a/tests/auto/render/renderattribute/tst_renderattribute.cpp
+++ b/tests/auto/render/renderattribute/tst_renderattribute.cpp
@@ -47,10 +47,10 @@ private Q_SLOTS:
     void checkPeerPropertyMirroring()
     {
         // GIVEN
-        Qt3D::Render::RenderAttribute renderAttribute;
+        Qt3DRender::Render::RenderAttribute renderAttribute;
 
-        Qt3D::QAttribute attribute;
-        attribute.setAttributeType(Qt3D::QAttribute::IndexAttribute);
+        Qt3DRender::QAttribute attribute;
+        attribute.setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
         attribute.setByteOffset(1200);
         attribute.setByteStride(883);
         attribute.setCount(427);
@@ -59,8 +59,8 @@ private Q_SLOTS:
         attribute.setDataType(Qt3D::QAbstractAttribute::UnsignedShort);
         attribute.setDataSize(3);
 
-        Qt3D::QBuffer buffer(Qt3D::QBuffer::IndexBuffer);
-        buffer.setUsage(Qt3D::QBuffer::DynamicCopy);
+        Qt3DRender::QBuffer buffer(Qt3DRender::QBuffer::IndexBuffer);
+        buffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
         buffer.setData(QByteArrayLiteral("Corvette"));
         attribute.setBuffer(&buffer);
 
@@ -84,7 +84,7 @@ private Q_SLOTS:
     void checkInitialAndCleanedUpState()
     {
         // GIVEN
-        Qt3D::Render::RenderAttribute renderAttribute;
+        Qt3DRender::Render::RenderAttribute renderAttribute;
 
         // THEN
         QVERIFY(renderAttribute.peerUuid().isNull());
@@ -93,15 +93,15 @@ private Q_SLOTS:
         QCOMPARE(renderAttribute.isDirty(), false);
         QCOMPARE(renderAttribute.dataType(), Qt3D::QAbstractAttribute::Float);
         QCOMPARE(renderAttribute.dataSize(), 1U);
-        QCOMPARE(renderAttribute.attributeType(), Qt3D::QAttribute::VertexAttribute);
+        QCOMPARE(renderAttribute.attributeType(), Qt3DRender::QAttribute::VertexAttribute);
         QCOMPARE(renderAttribute.byteOffset(), 0U);
         QCOMPARE(renderAttribute.byteStride(), 0U);
         QCOMPARE(renderAttribute.count(), 0U);
         QCOMPARE(renderAttribute.divisor(), 0U);
 
         // GIVEN
-        Qt3D::QAttribute attribute;
-        attribute.setAttributeType(Qt3D::QAttribute::IndexAttribute);
+        Qt3DRender::QAttribute attribute;
+        attribute.setAttributeType(Qt3DRender::QAttribute::IndexAttribute);
         attribute.setByteOffset(1200);
         attribute.setByteStride(883);
         attribute.setCount(427);
@@ -109,8 +109,8 @@ private Q_SLOTS:
         attribute.setName(QStringLiteral("C3"));
         attribute.setDataType(Qt3D::QAbstractAttribute::Double);
         attribute.setDataSize(4);
-        Qt3D::QBuffer buffer(Qt3D::QBuffer::IndexBuffer);
-        buffer.setUsage(Qt3D::QBuffer::DynamicCopy);
+        Qt3DRender::QBuffer buffer(Qt3DRender::QBuffer::IndexBuffer);
+        buffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
         buffer.setData(QByteArrayLiteral("C7"));
         attribute.setBuffer(&buffer);
 
@@ -125,7 +125,7 @@ private Q_SLOTS:
         QCOMPARE(renderAttribute.isDirty(), false);
         QCOMPARE(renderAttribute.dataType(), Qt3D::QAbstractAttribute::Float);
         QCOMPARE(renderAttribute.dataSize(), 1U);
-        QCOMPARE(renderAttribute.attributeType(), Qt3D::QAttribute::VertexAttribute);
+        QCOMPARE(renderAttribute.attributeType(), Qt3DRender::QAttribute::VertexAttribute);
         QCOMPARE(renderAttribute.byteOffset(), 0U);
         QCOMPARE(renderAttribute.byteStride(), 0U);
         QCOMPARE(renderAttribute.count(), 0U);
@@ -135,7 +135,7 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
-        Qt3D::Render::RenderAttribute renderAttribute;
+        Qt3DRender::Render::RenderAttribute renderAttribute;
 
         QVERIFY(!renderAttribute.isDirty());
 
@@ -167,12 +167,12 @@ private Q_SLOTS:
 
         // WHEN
         updateChange.reset(new Qt3D::QScenePropertyChange(Qt3D::NodeUpdated, Qt3D::QSceneChange::Node, Qt3D::QNodeId()));
-        updateChange->setValue(static_cast<int>(Qt3D::QAttribute::IndexAttribute));
+        updateChange->setValue(static_cast<int>(Qt3DRender::QAttribute::IndexAttribute));
         updateChange->setPropertyName("attributeType");
         renderAttribute.sceneChangeEvent(updateChange);
 
         // THEN
-        QCOMPARE(renderAttribute.attributeType(), Qt3D::QAttribute::IndexAttribute);
+        QCOMPARE(renderAttribute.attributeType(), Qt3DRender::QAttribute::IndexAttribute);
         QVERIFY(renderAttribute.isDirty());
 
         renderAttribute.unsetDirty();
diff --git a/tests/auto/render/renderbuffer/tst_renderbuffer.cpp b/tests/auto/render/renderbuffer/tst_renderbuffer.cpp
index 0f66e1cf2..1f74f2809 100644
--- a/tests/auto/render/renderbuffer/tst_renderbuffer.cpp
+++ b/tests/auto/render/renderbuffer/tst_renderbuffer.cpp
@@ -38,7 +38,7 @@
 #include <Qt3DRenderer/private/renderbuffer_p.h>
 #include <Qt3DCore/qscenepropertychange.h>
 
-class TestFunctor : public Qt3D::QBufferFunctor
+class TestFunctor : public Qt3DRender::QBufferFunctor
 {
 public:
     explicit TestFunctor(int size)
@@ -50,7 +50,7 @@ public:
         return QByteArray();
     }
 
-    bool operator ==(const Qt3D::QBufferFunctor &other) const
+    bool operator ==(const Qt3DRender::QBufferFunctor &other) const
     {
         const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other);
         if (otherFunctor != Q_NULLPTR)
@@ -72,11 +72,11 @@ private Q_SLOTS:
     void checkPeerPropertyMirroring()
     {
         // GIVEN
-        Qt3D::Render::RenderBuffer renderBuffer;
-        Qt3D::QBuffer buffer(Qt3D::QBuffer::IndexBuffer);
-        buffer.setUsage(Qt3D::QBuffer::DynamicCopy);
+        Qt3DRender::Render::RenderBuffer renderBuffer;
+        Qt3DRender::QBuffer buffer(Qt3DRender::QBuffer::IndexBuffer);
+        buffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
         buffer.setData(QByteArrayLiteral("Corvette"));
-        buffer.setBufferFunctor(Qt3D::QBufferFunctorPtr(new TestFunctor(883)));
+        buffer.setBufferFunctor(Qt3DRender::QBufferFunctorPtr(new TestFunctor(883)));
 
         // WHEN
         renderBuffer.setPeer(&buffer);
@@ -94,21 +94,21 @@ private Q_SLOTS:
     void checkInitialAndCleanedUpState()
     {
         // GIVEN
-        Qt3D::Render::RenderBuffer renderBuffer;
+        Qt3DRender::Render::RenderBuffer renderBuffer;
 
         // THEN
         QCOMPARE(renderBuffer.isDirty(), false);
-        QCOMPARE(renderBuffer.type(), Qt3D::QBuffer::VertexBuffer);
-        QCOMPARE(renderBuffer.usage(), Qt3D::QBuffer::StaticDraw);
+        QCOMPARE(renderBuffer.type(), Qt3DRender::QBuffer::VertexBuffer);
+        QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
         QVERIFY(renderBuffer.data().isEmpty());
         QVERIFY(renderBuffer.peerUuid().isNull());
         QVERIFY(renderBuffer.bufferFunctor().isNull());
 
         // GIVEN
-        Qt3D::QBuffer buffer(Qt3D::QBuffer::IndexBuffer);
-        buffer.setUsage(Qt3D::QBuffer::DynamicCopy);
+        Qt3DRender::QBuffer buffer(Qt3DRender::QBuffer::IndexBuffer);
+        buffer.setUsage(Qt3DRender::QBuffer::DynamicCopy);
         buffer.setData(QByteArrayLiteral("C7"));
-        buffer.setBufferFunctor(Qt3D::QBufferFunctorPtr(new TestFunctor(73)));
+        buffer.setBufferFunctor(Qt3DRender::QBufferFunctorPtr(new TestFunctor(73)));
 
         // WHEN
         renderBuffer.updateFromPeer(&buffer);
@@ -116,8 +116,8 @@ private Q_SLOTS:
 
         // THEN
         QCOMPARE(renderBuffer.isDirty(), false);
-        QCOMPARE(renderBuffer.type(), Qt3D::QBuffer::VertexBuffer);
-        QCOMPARE(renderBuffer.usage(), Qt3D::QBuffer::StaticDraw);
+        QCOMPARE(renderBuffer.type(), Qt3DRender::QBuffer::VertexBuffer);
+        QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::StaticDraw);
         QVERIFY(renderBuffer.data().isEmpty());
         QVERIFY(renderBuffer.bufferFunctor().isNull());
     }
@@ -125,22 +125,22 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
-        Qt3D::Render::RenderBuffer renderBuffer;
+        Qt3DRender::Render::RenderBuffer renderBuffer;
 
         // THEN
-        QVERIFY(renderBuffer.type() != Qt3D::QBuffer::IndexBuffer);
+        QVERIFY(renderBuffer.type() != Qt3DRender::QBuffer::IndexBuffer);
         QVERIFY(renderBuffer.data().isEmpty());
-        QVERIFY(renderBuffer.usage() != Qt3D::QBuffer::DynamicRead);
+        QVERIFY(renderBuffer.usage() != Qt3DRender::QBuffer::DynamicRead);
         QVERIFY(!renderBuffer.isDirty());
 
         // WHEN
         Qt3D::QScenePropertyChangePtr updateChange(new Qt3D::QScenePropertyChange(Qt3D::NodeUpdated, Qt3D::QSceneChange::Node, Qt3D::QNodeId()));
-        updateChange->setValue(static_cast<int>(Qt3D::QBuffer::IndexBuffer));
+        updateChange->setValue(static_cast<int>(Qt3DRender::QBuffer::IndexBuffer));
         updateChange->setPropertyName("type");
         renderBuffer.sceneChangeEvent(updateChange);
 
         // THEN
-        QCOMPARE(renderBuffer.type(), Qt3D::QBuffer::IndexBuffer);
+        QCOMPARE(renderBuffer.type(), Qt3DRender::QBuffer::IndexBuffer);
         QVERIFY(renderBuffer.isDirty());
 
         renderBuffer.unsetDirty();
@@ -148,12 +148,12 @@ private Q_SLOTS:
 
         // WHEN
         updateChange.reset(new Qt3D::QScenePropertyChange(Qt3D::NodeUpdated, Qt3D::QSceneChange::Node, Qt3D::QNodeId()));
-        updateChange->setValue(static_cast<int>(Qt3D::QBuffer::DynamicRead));
+        updateChange->setValue(static_cast<int>(Qt3DRender::QBuffer::DynamicRead));
         updateChange->setPropertyName("usage");
         renderBuffer.sceneChangeEvent(updateChange);
 
         // THEN
-        QCOMPARE(renderBuffer.usage(), Qt3D::QBuffer::DynamicRead);
+        QCOMPARE(renderBuffer.usage(), Qt3DRender::QBuffer::DynamicRead);
         QVERIFY(renderBuffer.isDirty());
 
         renderBuffer.unsetDirty();
@@ -175,7 +175,7 @@ private Q_SLOTS:
 
 
         // WHEN
-        Qt3D::QBufferFunctorPtr functor(new TestFunctor(355));
+        Qt3DRender::QBufferFunctorPtr functor(new TestFunctor(355));
         updateChange.reset(new Qt3D::QScenePropertyChange(Qt3D::NodeUpdated, Qt3D::QSceneChange::Node, Qt3D::QNodeId()));
         updateChange->setValue(QVariant::fromValue(functor));
         updateChange->setPropertyName("bufferFunctor");
diff --git a/tests/auto/render/renderentity/tst_renderentity.cpp b/tests/auto/render/renderentity/tst_renderentity.cpp
index f6ba098d6..a692c44d8 100644
--- a/tests/auto/render/renderentity/tst_renderentity.cpp
+++ b/tests/auto/render/renderentity/tst_renderentity.cpp
@@ -47,11 +47,12 @@
 #include <Qt3DRenderer/QShaderData>
 #include <Qt3DRenderer/QGeometryRenderer>
 
-typedef Qt3D::QNodeId (*UuidMethod)(Qt3D::Render::RenderEntity *);
-typedef QList<Qt3D::QNodeId> (*UuidListMethod)(Qt3D::Render::RenderEntity *);
+typedef Qt3D::QNodeId (*UuidMethod)(Qt3DRender::Render::RenderEntity *);
+typedef QList<Qt3D::QNodeId> (*UuidListMethod)(Qt3DRender::Render::RenderEntity *);
 
 using namespace Qt3D;
-using namespace Qt3D::Render;
+using namespace Qt3DRender;
+using namespace Qt3DRender::Render;
 
 void noopDeleter(QNode *) {}
 
diff --git a/tests/auto/render/rendergeometry/tst_rendergeometry.cpp b/tests/auto/render/rendergeometry/tst_rendergeometry.cpp
index df48997d9..0d1a3d0b3 100644
--- a/tests/auto/render/rendergeometry/tst_rendergeometry.cpp
+++ b/tests/auto/render/rendergeometry/tst_rendergeometry.cpp
@@ -48,13 +48,13 @@ private Q_SLOTS:
     void checkPeerPropertyMirroring()
     {
         // GIVEN
-        Qt3D::Render::RenderGeometry renderGeometry;
+        Qt3DRender::Render::RenderGeometry renderGeometry;
 
-        Qt3D::QGeometry geometry;
-        Qt3D::QAttribute attr1;
-        Qt3D::QAttribute attr2;
-        Qt3D::QAttribute attr4;
-        Qt3D::QAttribute attr3;
+        Qt3DRender::QGeometry geometry;
+        Qt3DRender::QAttribute attr1;
+        Qt3DRender::QAttribute attr2;
+        Qt3DRender::QAttribute attr4;
+        Qt3DRender::QAttribute attr3;
 
         geometry.addAttribute(&attr1);
         geometry.addAttribute(&attr2);
@@ -78,7 +78,7 @@ private Q_SLOTS:
     void checkInitialAndCleanedUpState()
     {
         // GIVEN
-        Qt3D::Render::RenderGeometry renderGeometry;
+        Qt3DRender::Render::RenderGeometry renderGeometry;
 
         // THEN
         QCOMPARE(renderGeometry.isDirty(), false);
@@ -87,11 +87,11 @@ private Q_SLOTS:
         QCOMPARE(renderGeometry.verticesPerPatch(), 0);
 
         // GIVEN
-        Qt3D::QGeometry geometry;
-        Qt3D::QAttribute attr1;
-        Qt3D::QAttribute attr2;
-        Qt3D::QAttribute attr4;
-        Qt3D::QAttribute attr3;
+        Qt3DRender::QGeometry geometry;
+        Qt3DRender::QAttribute attr1;
+        Qt3DRender::QAttribute attr2;
+        Qt3DRender::QAttribute attr4;
+        Qt3DRender::QAttribute attr3;
 
         geometry.addAttribute(&attr1);
         geometry.addAttribute(&attr2);
@@ -112,7 +112,7 @@ private Q_SLOTS:
     void checkPropertyChanges()
     {
         // GIVEN
-        Qt3D::Render::RenderGeometry renderGeometry;
+        Qt3DRender::Render::RenderGeometry renderGeometry;
         Qt3D::QNodeId geometryId = Qt3D::QNodeId::createId();
 
         // WHEN
diff --git a/tests/auto/render/rendergeometryrenderer/tst_rendergeometryrenderer.cpp b/tests/auto/render/rendergeometryrenderer/tst_rendergeometryrenderer.cpp
index 1c018865b..ab0d917c9 100644
--- a/tests/auto/render/rendergeometryrenderer/tst_rendergeometryrenderer.cpp
+++ b/tests/auto/render/rendergeometryrenderer/tst_rendergeometryrenderer.cpp
@@ -40,19 +40,19 @@
 #include <Qt3DRenderer/qgeometryfunctor.h>
 #include <Qt3DCore/qscenepropertychange.h>
 
-class TestFunctor : public Qt3D::QGeometryFunctor
+class TestFunctor : public Qt3DRender::QGeometryFunctor
 {
 public:
     explicit TestFunctor(int size)
         : m_size(size)
     {}
 
-    Qt3D::QGeometry *operator ()() Q_DECL_FINAL
+    Qt3DRender::QGeometry *operator ()() Q_DECL_FINAL
     {
         return Q_NULLPTR;
     }
 
-    bool operator ==(const Qt3D::QGeometryFunctor &other) const
+    bool operator ==(const Qt3DRender::QGeometryFunctor &other) const
     {
         const TestFunctor *otherFunctor = functor_cast<TestFunctor>(&other);
         if (otherFunctor != Q_NULLPTR)
@@ -74,10 +74,10 @@ private Q_SLOTS:
     void checkPeerPropertyMirroring()
     {
         // GIVEN
-        Qt3D::Render::RenderGeometryRenderer renderGeometryRenderer;
-        Qt3D::QGeometryRenderer geometryRenderer;
-        Qt3D::QGeometry geometry;
-        Qt3D::QGeometryFunctorPtr functor(new TestFunctor(1200));
+        Qt3DRender::Render::RenderGeometryRenderer renderGeometryRenderer;
+        Qt3DRender::QGeometryRenderer geometryRenderer;
+        Qt3DRender::QGeometry geometry;
+        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(1200));
 
         geometryRenderer.setInstanceCount(1584);
         geometryRenderer.setPrimitiveCount(1609);
@@ -85,7 +85,7 @@ private Q_SLOTS:
         geometryRenderer.setBaseInstance(883);
         geometryRenderer.setRestartIndex(65536);
         geometryRenderer.setPrimitiveRestart(true);
-        geometryRenderer.setPrimitiveType(Qt3D::QGeometryRenderer::Patches);
+        geometryRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
         geometryRenderer.setGeometry(&geometry);
         geometryRenderer.setGeometryFunctor(functor);
 
@@ -110,7 +110,7 @@ private Q_SLOTS:
     void checkInitialAndCleanedUpState()
     {
         // GIVEN
-        Qt3D::Render::RenderGeometryRenderer renderGeometryRenderer;
+        Qt3DRender::Render::RenderGeometryRenderer renderGeometryRenderer;
 
         // THEN
         QVERIFY(renderGeometryRenderer.peerUuid().isNull());
@@ -122,13 +122,13 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.baseInstance(), 0);
         QCOMPARE(renderGeometryRenderer.restartIndex(), -1);
         QCOMPARE(renderGeometryRenderer.primitiveRestart(), false);
-        QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3D::QGeometryRenderer::Triangles);
+        QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::Triangles);
         QVERIFY(renderGeometryRenderer.geometryFunctor().isNull());
 
         // GIVEN
-        Qt3D::QGeometryRenderer geometryRenderer;
-        Qt3D::QGeometry geometry;
-        Qt3D::QGeometryFunctorPtr functor(new TestFunctor(1200));
+        Qt3DRender::QGeometryRenderer geometryRenderer;
+        Qt3DRender::QGeometry geometry;
+        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(1200));
 
 
         geometryRenderer.setInstanceCount(454);
@@ -137,7 +137,7 @@ private Q_SLOTS:
         geometryRenderer.setBaseInstance(383);
         geometryRenderer.setRestartIndex(555);
         geometryRenderer.setPrimitiveRestart(true);
-        geometryRenderer.setPrimitiveType(Qt3D::QGeometryRenderer::Patches);
+        geometryRenderer.setPrimitiveType(Qt3DRender::QGeometryRenderer::Patches);
         geometryRenderer.setGeometry(&geometry);
         geometryRenderer.setGeometryFunctor(functor);
 
@@ -155,14 +155,14 @@ private Q_SLOTS:
         QCOMPARE(renderGeometryRenderer.baseInstance(), 0);
         QCOMPARE(renderGeometryRenderer.restartIndex(), -1);
         QCOMPARE(renderGeometryRenderer.primitiveRestart(), false);
-        QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3D::QGeometryRenderer::Triangles);
+        QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::Triangles);
         QVERIFY(renderGeometryRenderer.geometryFunctor().isNull());
     }
 
     void checkPropertyChanges()
     {
         // GIVEN
-        Qt3D::Render::RenderGeometryRenderer renderGeometryRenderer;
+        Qt3DRender::Render::RenderGeometryRenderer renderGeometryRenderer;
 
         QVERIFY(!renderGeometryRenderer.isDirty());
 
@@ -247,11 +247,11 @@ private Q_SLOTS:
         // WHEN
         updateChange.reset(new Qt3D::QScenePropertyChange(Qt3D::NodeUpdated, Qt3D::QSceneChange::Node, Qt3D::QNodeId()));
         updateChange->setPropertyName("primitiveType");
-        updateChange->setValue(static_cast<int>(Qt3D::QGeometryRenderer::LineLoop));
+        updateChange->setValue(static_cast<int>(Qt3DRender::QGeometryRenderer::LineLoop));
         renderGeometryRenderer.sceneChangeEvent(updateChange);
 
         // THEN
-        QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3D::QGeometryRenderer::LineLoop);
+        QCOMPARE(renderGeometryRenderer.primitiveType(), Qt3DRender::QGeometryRenderer::LineLoop);
         QVERIFY(renderGeometryRenderer.isDirty());
 
         renderGeometryRenderer.unsetDirty();
@@ -260,7 +260,7 @@ private Q_SLOTS:
         // WHEN
         updateChange.reset(new Qt3D::QScenePropertyChange(Qt3D::NodeUpdated, Qt3D::QSceneChange::Node, Qt3D::QNodeId()));
         updateChange->setPropertyName("geometryFunctor");
-        Qt3D::QGeometryFunctorPtr functor(new TestFunctor(1450));
+        Qt3DRender::QGeometryFunctorPtr functor(new TestFunctor(1450));
         updateChange->setValue(QVariant::fromValue(functor));
         renderGeometryRenderer.sceneChangeEvent(updateChange);
 
diff --git a/tests/auto/render/rendermaterial/tst_rendermaterial.cpp b/tests/auto/render/rendermaterial/tst_rendermaterial.cpp
index dcd3edd5e..c4669630a 100644
--- a/tests/auto/render/rendermaterial/tst_rendermaterial.cpp
+++ b/tests/auto/render/rendermaterial/tst_rendermaterial.cpp
@@ -44,7 +44,8 @@
 
 
 using namespace Qt3D;
-using namespace Qt3D::Render;
+using namespace Qt3DRender;
+using namespace Qt3DRender::Render;
 
 class tst_RenderMaterial : public QObject
 {
diff --git a/tests/auto/render/renderqueue/tst_renderqueue.cpp b/tests/auto/render/renderqueue/tst_renderqueue.cpp
index df0c96c2e..2fb01554b 100644
--- a/tests/auto/render/renderqueue/tst_renderqueue.cpp
+++ b/tests/auto/render/renderqueue/tst_renderqueue.cpp
@@ -61,7 +61,7 @@ private Q_SLOTS:
 void tst_RenderQueue::setRenderViewCount()
 {
     // GIVEN
-    Qt3D::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::RenderQueue renderQueue;
 
     // WHEN
     renderQueue.setTargetRenderViewCount(7);
@@ -74,7 +74,7 @@ void tst_RenderQueue::setRenderViewCount()
 void tst_RenderQueue::circleQueues()
 {
     // GIVEN
-    Qt3D::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::RenderQueue renderQueue;
     renderQueue.setTargetRenderViewCount(7);
 
     // WHEN
@@ -88,9 +88,9 @@ void tst_RenderQueue::circleQueues()
         QCOMPARE(renderQueue.currentRenderViewCount(), 0);
 
         // WHEN
-        QList<Qt3D::Render::RenderView *> renderViews;
+        QList<Qt3DRender::Render::RenderView *> renderViews;
         for (int i = 0; i < 7; i++) {
-            renderViews << new Qt3D::Render::RenderView();
+            renderViews << new Qt3DRender::Render::RenderView();
             renderQueue.queueRenderView(renderViews.at(i), i);
         }
 
@@ -102,19 +102,19 @@ void tst_RenderQueue::circleQueues()
 void tst_RenderQueue::checkOrder()
 {
     // GIVEN
-    Qt3D::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::RenderQueue renderQueue;
     renderQueue.setTargetRenderViewCount(7);
-    QVector<Qt3D::Render::RenderView *> renderViews(7);
+    QVector<Qt3DRender::Render::RenderView *> renderViews(7);
 
     // WHEN
     for (int i = 0; i < 7; ++i) {
         int processingOrder = (i % 2 == 0) ? (6 - i) : i;
-        renderViews[processingOrder] = new Qt3D::Render::RenderView();
+        renderViews[processingOrder] = new Qt3DRender::Render::RenderView();
         renderQueue.queueRenderView(renderViews[processingOrder], processingOrder);
     }
 
     // THEN
-    QVector<Qt3D::Render::RenderView *> frame = renderQueue.nextFrameQueue();
+    QVector<Qt3DRender::Render::RenderView *> frame = renderQueue.nextFrameQueue();
     for (int i = 0; i < 7; ++i) {
         QVERIFY(frame[i] == renderViews[i]);
     }
@@ -123,14 +123,14 @@ void tst_RenderQueue::checkOrder()
 void tst_RenderQueue::checkTimeToSubmit()
 {
     // GIVEN
-    Qt3D::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::RenderQueue renderQueue;
     renderQueue.setTargetRenderViewCount(7);
-    QVector<Qt3D::Render::RenderView *> renderViews(7);
+    QVector<Qt3DRender::Render::RenderView *> renderViews(7);
 
     // WHEN
     for (int i = 0; i < 7; i++) {
         int processingOrder = (i % 2 == 0) ? (6 - i) : i;
-        renderViews[processingOrder] = new Qt3D::Render::RenderView();
+        renderViews[processingOrder] = new Qt3DRender::Render::RenderView();
         renderQueue.queueRenderView(renderViews[processingOrder], processingOrder);
 
         // THEN
@@ -148,7 +148,7 @@ public:
     QWaitCondition m_waitTimeToSubmit;
     QWaitCondition m_waitToFillQueue;
     QMutex m_mutex;
-    Qt3D::Render::RenderQueue *m_renderQueues;
+    Qt3DRender::Render::RenderQueue *m_renderQueues;
 
 public Q_SLOTS:
 
@@ -166,7 +166,7 @@ public Q_SLOTS:
                 // THEN
                 QCOMPARE(m_renderQueues->currentRenderViewCount(), j);
                 // WHEN
-                m_renderQueues->queueRenderView(new Qt3D::Render::RenderView(), j);
+                m_renderQueues->queueRenderView(new Qt3DRender::Render::RenderView(), j);
                 // THEN
                 QVERIFY(m_renderQueues->targetRenderViewCount() == 7);
                 QCOMPARE(m_renderQueues->currentRenderViewCount(), j + 1);
@@ -184,7 +184,7 @@ public Q_SLOTS:
 void tst_RenderQueue::concurrentQueueAccess()
 {
     // GIVEN
-    Qt3D::Render::RenderQueue *renderQueue = new Qt3D::Render::RenderQueue;
+    Qt3DRender::Render::RenderQueue *renderQueue = new Qt3DRender::Render::RenderQueue;
 
     SimpleWorker *jobsThread = new SimpleWorker();
     renderQueue->setTargetRenderViewCount(7);
@@ -222,7 +222,7 @@ void tst_RenderQueue::concurrentQueueAccess()
 void tst_RenderQueue::resetQueue()
 {
     // GIVEN
-    Qt3D::Render::RenderQueue renderQueue;
+    Qt3DRender::Render::RenderQueue renderQueue;
 
     for (int j = 0; j < 5; j++) {
         // WHEN
@@ -231,7 +231,7 @@ void tst_RenderQueue::resetQueue()
         QVERIFY(renderQueue.currentRenderViewCount() == 0);
 
         // WHEN
-        QVector<Qt3D::Render::RenderView *> renderViews(5);
+        QVector<Qt3DRender::Render::RenderView *> renderViews(5);
         for (int i = 0; i < 5; ++i) {
             renderQueue.queueRenderView(renderViews.at(i), i);
         }
diff --git a/tests/auto/render/renderrenderpass/tst_renderrenderpass.cpp b/tests/auto/render/renderrenderpass/tst_renderrenderpass.cpp
index bd97abb00..3bc709d3f 100644
--- a/tests/auto/render/renderrenderpass/tst_renderrenderpass.cpp
+++ b/tests/auto/render/renderrenderpass/tst_renderrenderpass.cpp
@@ -67,7 +67,8 @@
 #include <Qt3DRenderer/private/blendstate_p.h>
 
 using namespace Qt3D;
-using namespace Qt3D::Render;
+using namespace Qt3DRender;
+using namespace Qt3DRender::Render;
 
 Q_DECLARE_METATYPE(RenderState*)
 
diff --git a/tests/auto/render/rendershader/tst_rendershader.cpp b/tests/auto/render/rendershader/tst_rendershader.cpp
index 980058285..54f020aa1 100644
--- a/tests/auto/render/rendershader/tst_rendershader.cpp
+++ b/tests/auto/render/rendershader/tst_rendershader.cpp
@@ -49,9 +49,9 @@ private slots:
 };
 
 
-Qt3D::QShaderProgram *createFrontendShader()
+Qt3DRender::QShaderProgram *createFrontendShader()
 {
-    Qt3D::QShaderProgram *shader = new Qt3D::QShaderProgram();
+    Qt3DRender::QShaderProgram *shader = new Qt3DRender::QShaderProgram();
 
     shader->setVertexShaderCode(QByteArrayLiteral(
                                     "#version 150"\
@@ -78,7 +78,7 @@ Qt3D::QShaderProgram *createFrontendShader()
 
 void tst_RenderShader::hasCoherentInitialState()
 {
-    Qt3D::Render::RenderShader *shader = new Qt3D::Render::RenderShader();
+    Qt3DRender::Render::RenderShader *shader = new Qt3DRender::Render::RenderShader();
 
     QCOMPARE(shader->isLoaded(), false);
     QCOMPARE(shader->dna(), 0U);
@@ -92,22 +92,22 @@ void tst_RenderShader::hasCoherentInitialState()
 
 void tst_RenderShader::matchesFrontendPeer()
 {
-    Qt3D::QShaderProgram *frontend = createFrontendShader();
-    Qt3D::Render::RenderShader *backend = new Qt3D::Render::RenderShader();
+    Qt3DRender::QShaderProgram *frontend = createFrontendShader();
+    Qt3DRender::Render::RenderShader *backend = new Qt3DRender::Render::RenderShader();
 
     backend->updateFromPeer(frontend);
     QCOMPARE(backend->isLoaded(), false);
     QVERIFY(backend->dna() != 0U);
 
-    for (int i = Qt3D::QShaderProgram::Vertex; i <= Qt3D::QShaderProgram::Compute; ++i)
+    for (int i = Qt3DRender::QShaderProgram::Vertex; i <= Qt3DRender::QShaderProgram::Compute; ++i)
         QCOMPARE(backend->shaderCode()[i],
-                 frontend->shaderCode( static_cast<const Qt3D::QShaderProgram::ShaderType>(i)));
+                 frontend->shaderCode( static_cast<const Qt3DRender::QShaderProgram::ShaderType>(i)));
 }
 
 void tst_RenderShader::cleanupLeavesACoherentState()
 {
-    Qt3D::QShaderProgram *frontend = createFrontendShader();
-    Qt3D::Render::RenderShader *shader = new Qt3D::Render::RenderShader();
+    Qt3DRender::QShaderProgram *frontend = createFrontendShader();
+    Qt3DRender::Render::RenderShader *shader = new Qt3DRender::Render::RenderShader();
 
     shader->updateFromPeer(frontend);
 
diff --git a/tests/auto/render/renderviews/tst_renderviews.cpp b/tests/auto/render/renderviews/tst_renderviews.cpp
index a07a62f0d..ca4ecf6cc 100644
--- a/tests/auto/render/renderviews/tst_renderviews.cpp
+++ b/tests/auto/render/renderviews/tst_renderviews.cpp
@@ -45,8 +45,8 @@ private Q_SLOTS:
 
     void checkRenderViewSizeFitsWithAllocator()
     {
-        QVERIFY(sizeof(Qt3D::Render::RenderView) <= 128);
-        QVERIFY(sizeof(Qt3D::Render::RenderView::InnerData) <= 128);
+        QVERIFY(sizeof(Qt3DRender::Render::RenderView) <= 128);
+        QVERIFY(sizeof(Qt3DRender::Render::RenderView::InnerData) <= 128);
     }
 
     void testSort()
@@ -58,7 +58,7 @@ private Q_SLOTS:
     {
         // GIVEN
         Qt3D::QFrameAllocator allocator(128, 16, 128);
-        Qt3D::Render::RenderView *rv = allocator.allocate<Qt3D::Render::RenderView>();
+        Qt3DRender::Render::RenderView *rv = allocator.allocate<Qt3DRender::Render::RenderView>();
         rv->setAllocator(&allocator);
 
         // THEN
diff --git a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
index 61348100c..87a8a36de 100644
--- a/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
+++ b/tests/auto/render/renderviewutils/tst_renderviewutils.cpp
@@ -53,14 +53,14 @@ private Q_SLOTS:
     void topLevelStructValue();
 };
 
-class ScalarShaderData : public Qt3D::QShaderData
+class ScalarShaderData : public Qt3DRender::QShaderData
 {
     Q_OBJECT
     Q_PROPERTY(float scalar READ scalar WRITE setScalar NOTIFY scalarChanged)
 
 public:
     ScalarShaderData()
-        : Qt3D::QShaderData()
+        : Qt3DRender::QShaderData()
         , m_scalar(0.0f)
     {
     }
@@ -78,11 +78,11 @@ public:
         return m_scalar;
     }
 
-    QHash<QString, Qt3D::Render::ShaderUniform> buildUniformMap(const QString &blockName)
+    QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName)
     {
-        QHash<QString, Qt3D::Render::ShaderUniform> uniforms;
+        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms;
 
-        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3D::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::ShaderUniform());
 
         return uniforms;
     }
@@ -95,14 +95,14 @@ private:
 };
 
 
-class ArrayShaderData : public Qt3D::QShaderData
+class ArrayShaderData : public Qt3DRender::QShaderData
 {
     Q_OBJECT
     Q_PROPERTY(QVariantList array READ array WRITE setArray NOTIFY arrayChanged)
 
 public:
     ArrayShaderData()
-        : Qt3D::QShaderData()
+        : Qt3DRender::QShaderData()
     {
     }
 
@@ -119,11 +119,11 @@ public:
         return m_array;
     }
 
-    QHash<QString, Qt3D::Render::ShaderUniform> buildUniformMap(const QString &blockName)
+    QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName)
     {
-        QHash<QString, Qt3D::Render::ShaderUniform> uniforms;
+        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms;
 
-        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3D::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::ShaderUniform());
 
         return uniforms;
     }
@@ -135,7 +135,7 @@ private:
     QVariantList m_array;
 };
 
-class StructShaderData : public Qt3D::QShaderData
+class StructShaderData : public Qt3DRender::QShaderData
 {
     Q_OBJECT
     Q_PROPERTY(float scalar READ scalar WRITE setScalar NOTIFY scalarChanged)
@@ -143,7 +143,7 @@ class StructShaderData : public Qt3D::QShaderData
 
 public:
     StructShaderData()
-        : Qt3D::QShaderData()
+        : Qt3DRender::QShaderData()
         , m_scalar(0.0f)
     {
     }
@@ -174,12 +174,12 @@ public:
         return m_array;
     }
 
-    virtual QHash<QString, Qt3D::Render::ShaderUniform> buildUniformMap(const QString &blockName)
+    virtual QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName)
     {
-        QHash<QString, Qt3D::Render::ShaderUniform> uniforms;
+        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms;
 
-        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3D::Render::ShaderUniform());
-        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3D::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".scalar"), Qt3DRender::Render::ShaderUniform());
+        uniforms.insert(blockName + QStringLiteral(".array[0]"), Qt3DRender::Render::ShaderUniform());
 
         return uniforms;
     }
@@ -206,7 +206,7 @@ private:
 class MultiLevelStructShaderData : public StructShaderData
 {
     Q_OBJECT
-    Q_PROPERTY(Qt3D::QShaderData *inner READ inner WRITE setInner NOTIFY innerChanged)
+    Q_PROPERTY(Qt3DRender::QShaderData *inner READ inner WRITE setInner NOTIFY innerChanged)
 
 public:
     MultiLevelStructShaderData()
@@ -215,7 +215,7 @@ public:
     {
     }
 
-    void setInner(Qt3D::QShaderData *inner)
+    void setInner(Qt3DRender::QShaderData *inner)
     {
         if (inner != m_inner) {
             m_inner = inner;
@@ -223,22 +223,22 @@ public:
         }
     }
 
-    Qt3D::QShaderData *inner() const
+    Qt3DRender::QShaderData *inner() const
     {
         return m_inner;
     }
 
-    QHash<QString, Qt3D::Render::ShaderUniform> buildUniformMap(const QString &blockName) Q_DECL_OVERRIDE
+    QHash<QString, Qt3DRender::Render::ShaderUniform> buildUniformMap(const QString &blockName) Q_DECL_OVERRIDE
     {
-        QHash<QString, Qt3D::Render::ShaderUniform> innerUniforms;
+        QHash<QString, Qt3DRender::Render::ShaderUniform> innerUniforms;
 
         StructShaderData *innerData = Q_NULLPTR;
         if ((innerData = qobject_cast<StructShaderData *>(m_inner)) != Q_NULLPTR)
             innerUniforms = innerData->buildUniformMap(QStringLiteral(".inner"));
 
-        QHash<QString, Qt3D::Render::ShaderUniform> uniforms = StructShaderData::buildUniformMap(blockName);
-        QHash<QString, Qt3D::Render::ShaderUniform>::const_iterator it = innerUniforms.begin();
-        const QHash<QString, Qt3D::Render::ShaderUniform>::const_iterator end = innerUniforms.end();
+        QHash<QString, Qt3DRender::Render::ShaderUniform> uniforms = StructShaderData::buildUniformMap(blockName);
+        QHash<QString, Qt3DRender::Render::ShaderUniform>::const_iterator it = innerUniforms.begin();
+        const QHash<QString, Qt3DRender::Render::ShaderUniform>::const_iterator end = innerUniforms.end();
 
         while (it != end) {
             uniforms.insert(blockName + it.key(), it.value());
@@ -271,23 +271,23 @@ Q_SIGNALS:
     void innerChanged();
 
 private:
-    Qt3D::QShaderData *m_inner;
+    Qt3DRender::QShaderData *m_inner;
 };
 
 namespace {
 
-void initBackendShaderData(Qt3D::QShaderData *frontend,
-                           Qt3D::Render::ShaderDataManager *manager)
+void initBackendShaderData(Qt3DRender::QShaderData *frontend,
+                           Qt3DRender::Render::ShaderDataManager *manager)
 {
     // Create children first
     Q_FOREACH (QObject *c, frontend->children()) {
-        Qt3D::QShaderData *cShaderData = qobject_cast<Qt3D::QShaderData *>(c);
+        Qt3DRender::QShaderData *cShaderData = qobject_cast<Qt3DRender::QShaderData *>(c);
         if (cShaderData)
             initBackendShaderData(cShaderData, manager);
     }
 
     // Create backend element for frontend one
-    Qt3D::Render::RenderShaderData *backend = manager->getOrCreateResource(frontend->id());
+    Qt3DRender::Render::RenderShaderData *backend = manager->getOrCreateResource(frontend->id());
     // Init the backend element
     backend->updateFromPeer(frontend);
 }
@@ -298,15 +298,15 @@ void initBackendShaderData(Qt3D::QShaderData *frontend,
 void tst_RenderViewUtils::topLevelScalarValueNoUniforms()
 {
     QScopedPointer<ScalarShaderData> shaderData(new ScalarShaderData());
-    QScopedPointer<Qt3D::Render::ShaderDataManager> manager(new Qt3D::Render::ShaderDataManager());
+    QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
 
     shaderData->setScalar(883.0f);
     initBackendShaderData(shaderData.data(), manager.data());
 
-    Qt3D::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
+    Qt3DRender::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
     QVERIFY(backendShaderData != Q_NULLPTR);
 
-    Qt3D::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.updatedPropertiesOnly = false;
     // build name-value map
@@ -318,15 +318,15 @@ void tst_RenderViewUtils::topLevelScalarValueNoUniforms()
 void tst_RenderViewUtils::topLevelScalarValue()
 {
     QScopedPointer<ScalarShaderData> shaderData(new ScalarShaderData());
-    QScopedPointer<Qt3D::Render::ShaderDataManager> manager(new Qt3D::Render::ShaderDataManager());
+    QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
 
     shaderData->setScalar(883.0f);
     initBackendShaderData(shaderData.data(), manager.data());
 
-    Qt3D::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
+    Qt3DRender::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
     QVERIFY(backendShaderData != Q_NULLPTR);
 
-    Qt3D::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.updatedPropertiesOnly = false;
     blockBuilder.uniforms = shaderData->buildUniformMap(QStringLiteral("MyBlock"));
@@ -349,16 +349,16 @@ void tst_RenderViewUtils::topLevelScalarValue()
 void tst_RenderViewUtils::topLevelArrayValue()
 {
     QScopedPointer<ArrayShaderData> shaderData(new ArrayShaderData());
-    QScopedPointer<Qt3D::Render::ShaderDataManager> manager(new Qt3D::Render::ShaderDataManager());
+    QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
 
     QVariantList arrayValues = QVariantList() << 454 << 350 << 383 << 427 << 552;
     shaderData->setArray(arrayValues);
     initBackendShaderData(shaderData.data(), manager.data());
 
-    Qt3D::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
+    Qt3DRender::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
     QVERIFY(backendShaderData != Q_NULLPTR);
 
-    Qt3D::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.updatedPropertiesOnly = false;
     blockBuilder.uniforms = shaderData->buildUniformMap(QStringLiteral("MyBlock"));
@@ -414,14 +414,14 @@ void tst_RenderViewUtils::topLevelStructValue()
 {
     QFETCH(StructShaderData *, shaderData);
     QFETCH(QString, blockName);
-    QScopedPointer<Qt3D::Render::ShaderDataManager> manager(new Qt3D::Render::ShaderDataManager());
+    QScopedPointer<Qt3DRender::Render::ShaderDataManager> manager(new Qt3DRender::Render::ShaderDataManager());
 
     initBackendShaderData(shaderData, manager.data());
 
-    Qt3D::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
+    Qt3DRender::Render::RenderShaderData *backendShaderData = manager->lookupResource(shaderData->id());
     QVERIFY(backendShaderData != Q_NULLPTR);
 
-    Qt3D::Render::UniformBlockValueBuilder blockBuilder;
+    Qt3DRender::Render::UniformBlockValueBuilder blockBuilder;
     blockBuilder.shaderDataManager = manager.data();
     blockBuilder.updatedPropertiesOnly = false;
     blockBuilder.uniforms = shaderData->buildUniformMap(blockName);
diff --git a/tests/auto/render/vsyncframeadvanceservice/tst_vsyncframeadvanceservice.cpp b/tests/auto/render/vsyncframeadvanceservice/tst_vsyncframeadvanceservice.cpp
index be19a3ada..48bfef9f3 100644
--- a/tests/auto/render/vsyncframeadvanceservice/tst_vsyncframeadvanceservice.cpp
+++ b/tests/auto/render/vsyncframeadvanceservice/tst_vsyncframeadvanceservice.cpp
@@ -41,7 +41,7 @@
 class FakeRenderThread Q_DECL_FINAL : public QThread
 {
 public:
-    FakeRenderThread(Qt3D::Render::VSyncFrameAdvanceService *tickService)
+    FakeRenderThread(Qt3DRender::Render::VSyncFrameAdvanceService *tickService)
         : m_tickService(tickService)
     {
     }
@@ -55,7 +55,7 @@ protected:
     }
 
 private:
-    Qt3D::Render::VSyncFrameAdvanceService *m_tickService;
+    Qt3DRender::Render::VSyncFrameAdvanceService *m_tickService;
 };
 
 class tst_VSyncFrameAdvanceService : public QObject
@@ -67,7 +67,7 @@ private Q_SLOTS:
     void checkSynchronisation()
     {
         // GIVEN
-        Qt3D::Render::VSyncFrameAdvanceService tickService;
+        Qt3DRender::Render::VSyncFrameAdvanceService tickService;
         FakeRenderThread renderThread(&tickService);
         QElapsedTimer t;