Merge remote-tracking branch 'origin/5.15' into dev

 Conflicts:
	examples/network/bearermonitor/CMakeLists.txt
	examples/network/CMakeLists.txt
	src/corelib/tools/qlinkedlist.h
	src/sql/kernel/qsqldriver_p.h
	src/sql/kernel/qsqlresult_p.h
	src/widgets/kernel/qwidget.cpp
	src/widgets/kernel/qwidget_p.h
	tests/auto/network/socket/platformsocketengine/tst_platformsocketengine.cpp
	tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
	tests/auto/tools/moc/allmocs_baseline_in.json

Change-Id: I21a3c34570ae79ea9d30107fae71759d7eac17d9

2 files changed, 242 insertions, 8 deletions

diff --git a/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp b/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp
index 59e93d127f..56df69dde8 100644
--- a/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp
+++ b/tests/auto/gui/util/qshadergenerator/tst_qshadergenerator.cpp
@@ -198,6 +198,9 @@ private slots:
     void shouldGenerateDifferentCodeDependingOnActiveLayers();
     void shouldUseGlobalVariableRatherThanTemporaries();
     void shouldGenerateTemporariesWisely();
+    void shouldHandlePortNamesPrefixingOneAnother();
+    void shouldHandleNodesWithMultipleOutputPorts();
+    void shouldHandleExpressionsInInputNodes();
 };
 
 void tst_QShaderGenerator::shouldHaveDefaultState()
@@ -1229,6 +1232,196 @@ void tst_QShaderGenerator::shouldGenerateTemporariesWisely()
     }
 }
 
+void tst_QShaderGenerator::shouldHandlePortNamesPrefixingOneAnother()
+{
+    // GIVEN
+    const auto gl4 = createFormat(QShaderFormat::OpenGLCoreProfile, 4, 0);
+
+    auto color1 = createNode({
+                                 createPort(QShaderNodePort::Output, "output")
+                             });
+    color1.addRule(gl4, QShaderNode::Rule("vec4 $output = color1;",
+                                          QByteArrayList() << "in vec4 color1;"));
+
+    auto color2 = createNode({
+                                 createPort(QShaderNodePort::Output, "output")
+                             });
+    color2.addRule(gl4, QShaderNode::Rule("vec4 $output = color2;",
+                                          QByteArrayList() << "in vec4 color2;"));
+
+    auto addColor = createNode({
+                                   createPort(QShaderNodePort::Output, "color"),
+                                   createPort(QShaderNodePort::Input, "color1"),
+                                   createPort(QShaderNodePort::Input, "color2"),
+                               });
+    addColor.addRule(gl4, QShaderNode::Rule("vec4 $color = $color1 + $color2;"));
+
+    auto shaderOutput = createNode({
+                                       createPort(QShaderNodePort::Input, "input")
+                                   });
+
+    shaderOutput.addRule(gl4, QShaderNode::Rule("shaderOutput = $input;",
+                                                QByteArrayList() << "out vec4 shaderOutput;"));
+
+    // WHEN
+    const auto graph = [=] {
+        auto res = QShaderGraph();
+
+        res.addNode(color1);
+        res.addNode(color2);
+        res.addNode(addColor);
+        res.addNode(shaderOutput);
+
+        res.addEdge(createEdge(color1.uuid(), "output", addColor.uuid(), "color1"));
+        res.addEdge(createEdge(color2.uuid(), "output", addColor.uuid(), "color2"));
+        res.addEdge(createEdge(addColor.uuid(), "color", shaderOutput.uuid(), "input"));
+
+        return res;
+    }();
+
+    auto generator = QShaderGenerator();
+    generator.graph = graph;
+    generator.format = gl4;
+
+    const auto code = generator.createShaderCode();
+
+    // THEN
+    const auto expected = QByteArrayList()
+            << "#version 400 core"
+            << ""
+            << "in vec4 color1;"
+            << "in vec4 color2;"
+            << "out vec4 shaderOutput;"
+            << ""
+            << "void main()"
+            << "{"
+            << "    shaderOutput = ((color1 + color2));"
+            << "}"
+            << "";
+    QCOMPARE(code, expected.join("\n"));
+}
+
+void tst_QShaderGenerator::shouldHandleNodesWithMultipleOutputPorts()
+{
+    // GIVEN
+    const auto gl4 = createFormat(QShaderFormat::OpenGLCoreProfile, 4, 0);
+
+    auto input = createNode({
+                                createPort(QShaderNodePort::Output, "output0"),
+                                createPort(QShaderNodePort::Output, "output1")
+                            });
+    input.addRule(gl4, QShaderNode::Rule("vec4 $output0 = globalIn0;"
+                                         "float $output1 = globalIn1;",
+                                         QByteArrayList() << "in vec4 globalIn0;" << "in float globalIn1;"));
+
+    auto function = createNode({
+                                   createPort(QShaderNodePort::Input, "input0"),
+                                   createPort(QShaderNodePort::Input, "input1"),
+                                   createPort(QShaderNodePort::Output, "output0"),
+                                   createPort(QShaderNodePort::Output, "output1")
+                               });
+    function.addRule(gl4, QShaderNode::Rule("vec4 $output0 = $input0;"
+                                            "float $output1 = $input1;"));
+
+    auto output = createNode({
+                                 createPort(QShaderNodePort::Input, "input0"),
+                                 createPort(QShaderNodePort::Input, "input1")
+                             });
+
+    output.addRule(gl4, QShaderNode::Rule("globalOut0 = $input0;"
+                                          "globalOut1 = $input1;",
+                                          QByteArrayList() << "out vec4 globalOut0;" << "out float globalOut1;"));
+
+    // WHEN
+    const auto graph = [=] {
+        auto res = QShaderGraph();
+
+        res.addNode(input);
+        res.addNode(function);
+        res.addNode(output);
+
+        res.addEdge(createEdge(input.uuid(), "output0", function.uuid(), "input0"));
+        res.addEdge(createEdge(input.uuid(), "output1", function.uuid(), "input1"));
+
+        res.addEdge(createEdge(function.uuid(), "output0", output.uuid(), "input0"));
+        res.addEdge(createEdge(function.uuid(), "output1", output.uuid(), "input1"));
+
+        return res;
+    }();
+
+    auto generator = QShaderGenerator();
+    generator.graph = graph;
+    generator.format = gl4;
+
+    const auto code = generator.createShaderCode();
+
+    // THEN
+    const auto expected = QByteArrayList()
+            << "#version 400 core"
+            << ""
+            << "in vec4 globalIn0;"
+            << "in float globalIn1;"
+            << "out vec4 globalOut0;"
+            << "out float globalOut1;"
+            << ""
+            << "void main()"
+            << "{"
+            << "    globalOut0 = globalIn0;"
+            << "    globalOut1 = globalIn1;"
+            << "}"
+            << "";
+    QCOMPARE(code, expected.join("\n"));
+}
+
+void tst_QShaderGenerator::shouldHandleExpressionsInInputNodes()
+{
+    // GIVEN
+    const auto gl4 = createFormat(QShaderFormat::OpenGLCoreProfile, 4, 0);
+
+    auto input = createNode({
+                                createPort(QShaderNodePort::Output, "output")
+                            });
+    input.addRule(gl4, QShaderNode::Rule("float $output = 3 + 4;"));
+
+    auto output = createNode({
+                                 createPort(QShaderNodePort::Input, "input")
+                             });
+
+    output.addRule(gl4, QShaderNode::Rule("globalOut = $input;",
+                                          QByteArrayList() << "out float globalOut;"));
+
+    // WHEN
+    const auto graph = [=] {
+        auto res = QShaderGraph();
+
+        res.addNode(input);
+        res.addNode(output);
+
+        res.addEdge(createEdge(input.uuid(), "output", output.uuid(), "input"));
+
+        return res;
+    }();
+
+    auto generator = QShaderGenerator();
+    generator.graph = graph;
+    generator.format = gl4;
+
+    const auto code = generator.createShaderCode();
+
+    // THEN
+    const auto expected = QByteArrayList()
+            << "#version 400 core"
+            << ""
+            << "out float globalOut;"
+            << ""
+            << "void main()"
+            << "{"
+            << "    globalOut = 3 + 4;"
+            << "}"
+            << "";
+    QCOMPARE(code, expected.join("\n"));
+}
+
 QTEST_MAIN(tst_QShaderGenerator)
 
 #include "tst_qshadergenerator.moc"
diff --git a/tests/auto/gui/util/qshadergraph/tst_qshadergraph.cpp b/tests/auto/gui/util/qshadergraph/tst_qshadergraph.cpp
index ce2d38c24f..014a163f58 100644
--- a/tests/auto/gui/util/qshadergraph/tst_qshadergraph.cpp
+++ b/tests/auto/gui/util/qshadergraph/tst_qshadergraph.cpp
@@ -114,6 +114,7 @@ private slots:
     void shouldSurviveCyclesDuringGraphSerialization();
     void shouldDealWithEdgesJumpingOverLayers();
     void shouldGenerateDifferentStatementsDependingOnActiveLayers();
+    void shouldDealWithBranchesWithoutOutput();
 };
 
 void tst_QShaderGraph::shouldHaveEdgeDefaultState()
@@ -515,12 +516,9 @@ void tst_QShaderGraph::shouldHandleUnboundPortsDuringGraphSerialization()
     const auto statements = graph.createStatements();
 
     // THEN
-    // Note that no edge leads to the unbound input
+    // Note that no statement has any unbound input
     const auto expected = QVector<QShaderGraph::Statement>()
-            << createStatement(input, {}, {0})
-            << createStatement(function, {-1, 0, -1}, {2, 3, 4})
-            << createStatement(unboundOutput, {-1}, {})
-            << createStatement(output, {3}, {});
+            << createStatement(input, {}, {0});
     dumpStatementsIfNeeded(statements, expected);
     QCOMPARE(statements, expected);
 }
@@ -567,9 +565,8 @@ void tst_QShaderGraph::shouldSurviveCyclesDuringGraphSerialization()
     const auto statements = graph.createStatements();
 
     // THEN
-    // Obviously will lead to a compile failure later on since it cuts everything beyond the cycle
-    const auto expected = QVector<QShaderGraph::Statement>()
-            << createStatement(output, {2}, {});
+    // The cycle is ignored
+    const auto expected = QVector<QShaderGraph::Statement>();
     dumpStatementsIfNeeded(statements, expected);
     QCOMPARE(statements, expected);
 }
@@ -774,6 +771,50 @@ void tst_QShaderGraph::shouldGenerateDifferentStatementsDependingOnActiveLayers(
     }
 }
 
+void tst_QShaderGraph::shouldDealWithBranchesWithoutOutput()
+{
+    // GIVEN
+    const auto input = createNode({
+        createPort(QShaderNodePort::Output, "input")
+    });
+    const auto output = createNode({
+        createPort(QShaderNodePort::Input, "output")
+    });
+    const auto danglingFunction = createNode({
+        createPort(QShaderNodePort::Input, "functionInput"),
+        createPort(QShaderNodePort::Output, "unbound")
+    });
+    const auto function = createNode({
+        createPort(QShaderNodePort::Input, "functionInput"),
+        createPort(QShaderNodePort::Output, "functionOutput")
+    });
+
+    const auto graph = [=] {
+        auto res = QShaderGraph();
+        res.addNode(input);
+        res.addNode(function);
+        res.addNode(danglingFunction);
+        res.addNode(output);
+        res.addEdge(createEdge(input.uuid(), "input", function.uuid(), "functionInput"));
+        res.addEdge(createEdge(input.uuid(), "input", danglingFunction.uuid(), "functionInput"));
+        res.addEdge(createEdge(function.uuid(), "functionOutput", output.uuid(), "output"));
+        return res;
+    }();
+
+    // WHEN
+    const auto statements = graph.createStatements();
+
+    // THEN
+    // Note that no edge leads to the unbound input
+    const auto expected = QVector<QShaderGraph::Statement>()
+            << createStatement(input, {}, {0})
+            << createStatement(function, {0}, {1})
+            << createStatement(output, {1}, {})
+            << createStatement(danglingFunction, {0}, {2});
+    dumpStatementsIfNeeded(statements, expected);
+    QCOMPARE(statements, expected);
+}
+
 QTEST_MAIN(tst_QShaderGraph)
 
 #include "tst_qshadergraph.moc"