1 files changed, 44 insertions, 44 deletions

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();