2 files changed, 111 insertions, 2 deletions

diff --git a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
index 18dd1306a..15be26e8e 100644
--- a/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
+++ b/tests/auto/render/qshaderprogram/tst_qshaderprogram.cpp
@@ -45,6 +45,13 @@ class tst_QShaderProgram : public Qt3DRender::QShaderProgram
 {
     Q_OBJECT
 
+public:
+    tst_QShaderProgram()
+        : Qt3DRender::QShaderProgram()
+    {
+        qRegisterMetaType<Qt3DRender::QShaderProgram::Format>("Format");
+    }
+
 private Q_SLOTS:
 
     void checkDefaultConstruction()
@@ -61,6 +68,7 @@ private Q_SLOTS:
         QCOMPARE(shaderProgram.computeShaderCode(), QByteArray());
         QCOMPARE(shaderProgram.log(), QString());
         QCOMPARE(shaderProgram.status(), Qt3DRender::QShaderProgram::NotReady);
+        QCOMPARE(shaderProgram.format(), Qt3DRender::QShaderProgram::GLSL);
     }
 
     void checkPropertyChanges()
@@ -182,6 +190,25 @@ private Q_SLOTS:
             QCOMPARE(shaderProgram.computeShaderCode(), newValue);
             QCOMPARE(spy.count(), 0);
         }
+        {
+            // WHEN
+            QSignalSpy spy(&shaderProgram, SIGNAL(formatChanged(Format)));
+            const QShaderProgram::Format newValue = QShaderProgram::SPIRV;
+            shaderProgram.setFormat(newValue);
+
+            // THEN
+            QVERIFY(spy.isValid());
+            QCOMPARE(shaderProgram.format(), newValue);
+            QCOMPARE(spy.count(), 1);
+
+            // WHEN
+            spy.clear();
+            shaderProgram.setFormat(newValue);
+
+            // THEN
+            QCOMPARE(shaderProgram.format(), newValue);
+            QCOMPARE(spy.count(), 0);
+        }
     }
 
     void checkCreationData()
@@ -195,6 +222,7 @@ private Q_SLOTS:
         shaderProgram.setGeometryShaderCode(QByteArrayLiteral("Geometry"));
         shaderProgram.setFragmentShaderCode(QByteArrayLiteral("Fragment"));
         shaderProgram.setComputeShaderCode(QByteArrayLiteral("Compute"));
+        shaderProgram.setFormat(QShaderProgram::SPIRV);
 
         // WHEN
         QVector<Qt3DCore::QNodeCreatedChangeBasePtr> creationChanges;
@@ -217,6 +245,7 @@ private Q_SLOTS:
             QCOMPARE(shaderProgram.geometryShaderCode(), cloneData.geometryShaderCode);
             QCOMPARE(shaderProgram.fragmentShaderCode(), cloneData.fragmentShaderCode);
             QCOMPARE(shaderProgram.computeShaderCode(), cloneData.computeShaderCode);
+            QCOMPARE(shaderProgram.format(), cloneData.format);
             QCOMPARE(shaderProgram.id(), creationChangeData->subjectId());
             QCOMPARE(shaderProgram.isEnabled(), true);
             QCOMPARE(shaderProgram.isEnabled(), creationChangeData->isNodeEnabled());
@@ -532,6 +561,42 @@ private Q_SLOTS:
         // THEN
         QVERIFY(mainContent.indexOf(includedContent) == 0);
     }
+
+    void checkFormatPropertyUpdate()
+    {
+        // GIVEN
+        TestArbiter arbiter;
+        Qt3DRender::QShaderProgram shaderProgram;
+        arbiter.setArbiterOnNode(&shaderProgram);
+
+        QSignalSpy spy(&shaderProgram, SIGNAL(formatChanged(Format)));
+
+        // THEN
+        QVERIFY(spy.isValid());
+
+        {
+            // WHEN
+            shaderProgram.setFormat(QShaderProgram::SPIRV);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QCOMPARE(spy.count(), 1);
+            QCOMPARE(arbiter.events.size(), 0);
+
+            spy.clear();
+        }
+
+        {
+            // WHEN
+            shaderProgram.setFormat(QShaderProgram::SPIRV);
+            QCoreApplication::processEvents();
+
+            // THEN
+            QCOMPARE(spy.count(), 0);
+            QCOMPARE(arbiter.events.size(), 0);
+        }
+    }
+
 };
 
 QTEST_MAIN(tst_QShaderProgram)
diff --git a/tests/auto/render/shader/tst_shader.cpp b/tests/auto/render/shader/tst_shader.cpp
index 3f0714907..a1f837010 100644
--- a/tests/auto/render/shader/tst_shader.cpp
+++ b/tests/auto/render/shader/tst_shader.cpp
@@ -42,15 +42,17 @@ private slots:
     void cleanupLeavesACoherentState();
     void dealWithPropertyChanges_data();
     void dealWithPropertyChanges();
+    void dealWithFormatChanges();
     void checkSetRendererDirtyOnInitialization();
     void allowToChangeShaderCode_data();
     void allowToChangeShaderCode();
 };
 
 
-Qt3DRender::QShaderProgram *createFrontendShader()
+Qt3DRender::QShaderProgram *createFrontendShader(Qt3DRender::QShaderProgram::Format format = Qt3DRender::QShaderProgram::GLSL)
 {
     Qt3DRender::QShaderProgram *shader = new Qt3DRender::QShaderProgram();
+    shader->setFormat(format);
 
     shader->setVertexShaderCode(QByteArrayLiteral(
                                     "#version 150"\
@@ -80,6 +82,7 @@ void tst_RenderShader::hasCoherentInitialState()
     Qt3DRender::Render::Shader *shader = new Qt3DRender::Render::Shader();
 
     QCOMPARE(shader->status(), Qt3DRender::QShaderProgram::NotReady);
+    QCOMPARE(shader->format(), Qt3DRender::QShaderProgram::GLSL);
     QVERIFY(shader->log().isEmpty());
     QCOMPARE(shader->isDirty(), false);
 }
@@ -97,11 +100,12 @@ void tst_RenderShader::matchesFrontendPeer()
     for (int i = Qt3DRender::QShaderProgram::Vertex; i <= Qt3DRender::QShaderProgram::Compute; ++i)
         QCOMPARE(backend.shaderCode()[i],
                  frontend->shaderCode(static_cast<Qt3DRender::QShaderProgram::ShaderType>(i)));
+    QCOMPARE(backend.format(), frontend->format());
 }
 
 void tst_RenderShader::cleanupLeavesACoherentState()
 {
-    QScopedPointer<Qt3DRender::QShaderProgram> frontend(createFrontendShader());
+    QScopedPointer<Qt3DRender::QShaderProgram> frontend(createFrontendShader(Qt3DRender::QShaderProgram::SPIRV));
     TestRenderer renderer;
     Qt3DRender::Render::Shader shader;
 
@@ -112,6 +116,7 @@ void tst_RenderShader::cleanupLeavesACoherentState()
 
     QCOMPARE(shader.isDirty(), false);
     QCOMPARE(shader.status(), Qt3DRender::QShaderProgram::NotReady);
+    QCOMPARE(shader.format(), Qt3DRender::QShaderProgram::GLSL);
 }
 
 void tst_RenderShader::dealWithPropertyChanges_data()
@@ -176,6 +181,45 @@ void tst_RenderShader::dealWithPropertyChanges()
     QCOMPARE(backend.isDirty(), true);
 }
 
+void tst_RenderShader::dealWithFormatChanges()
+{
+    // GIVEN
+    Qt3DRender::Render::Shader backend;
+    Qt3DRender::QShaderProgram shader;
+    TestRenderer renderer;
+    backend.setRenderer(&renderer);
+    simulateInitializationSync(&shader, &backend);
+
+    // WHEN
+    shader.setFormat(Qt3DRender::QShaderProgram::GLSL);
+    backend.syncFromFrontEnd(&shader, false);
+
+    // THEN
+    QCOMPARE(backend.format(), Qt3DRender::QShaderProgram::GLSL);
+    QCOMPARE(backend.isDirty(), false);
+    QCOMPARE(renderer.dirtyBits(), 0);
+
+    // WHEN
+    shader.setFormat(Qt3DRender::QShaderProgram::SPIRV);
+    backend.syncFromFrontEnd(&shader, false);
+
+    // THEN
+    QCOMPARE(backend.format(), Qt3DRender::QShaderProgram::SPIRV);
+    QCOMPARE(renderer.dirtyBits(), Qt3DRender::Render::AbstractRenderer::ShadersDirty);
+    QCOMPARE(backend.isDirty(), true);
+
+    renderer.resetDirty();
+    backend.unsetDirty();
+
+    // WHEN
+    shader.setFormat(Qt3DRender::QShaderProgram::SPIRV);
+    backend.syncFromFrontEnd(&shader, false);
+
+    // THEN
+    QCOMPARE(backend.isDirty(), false);
+    QCOMPARE(renderer.dirtyBits(), 0);
+}
+
 void tst_RenderShader::checkSetRendererDirtyOnInitialization()
 {
     // GIVEN