/****************************************************************************
**
** Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
** Contact: https://www.qt.io/licensing/
**
** This file is part of the test suite of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/


#include <QtTest/QtTest>

#include <QtCore/qbuffer.h>

#include <QtGui/private/qshadergraphloader_p.h>
#include <QtGui/private/qshaderlanguage_p.h>

using QBufferPointer = QSharedPointer<QBuffer>;
Q_DECLARE_METATYPE(QBufferPointer);

using PrototypeHash = QHash<QString, QShaderNode>;
Q_DECLARE_METATYPE(PrototypeHash);

namespace
{
    QBufferPointer createBuffer(const QByteArray &data, QIODevice::OpenMode openMode = QIODevice::ReadOnly)
    {
        auto buffer = QBufferPointer::create();
        buffer->setData(data);
        if (openMode != QIODevice::NotOpen)
            buffer->open(openMode);
        return buffer;
    }

    QShaderFormat createFormat(QShaderFormat::Api api, int majorVersion, int minorVersion)
    {
        auto format = QShaderFormat();
        format.setApi(api);
        format.setVersion(QVersionNumber(majorVersion, minorVersion));
        return format;
    }

    QShaderNodePort createPort(QShaderNodePort::Direction portDirection, const QString &portName)
    {
        auto port = QShaderNodePort();
        port.direction = portDirection;
        port.name = portName;
        return port;
    }

    QShaderNode createNode(const QVector<QShaderNodePort> &ports, const QStringList &layers = QStringList())
    {
        auto node = QShaderNode();
        node.setUuid(QUuid::createUuid());
        node.setLayers(layers);
        for (const auto &port : ports)
            node.addPort(port);
        return node;
    }

    QShaderGraph::Edge createEdge(const QUuid &sourceUuid, const QString &sourceName,
                                  const QUuid &targetUuid, const QString &targetName,
                                  const QStringList &layers = QStringList())
    {
        auto edge = QShaderGraph::Edge();
        edge.sourceNodeUuid = sourceUuid;
        edge.sourcePortName = sourceName;
        edge.targetNodeUuid = targetUuid;
        edge.targetPortName = targetName;
        edge.layers = layers;
        return edge;
    }

    QShaderGraph createGraph()
    {
        const auto openGLES2 = createFormat(QShaderFormat::OpenGLES, 2, 0);
        const auto openGL3 = createFormat(QShaderFormat::OpenGLCoreProfile, 3, 0);

        auto graph = QShaderGraph();

        auto worldPosition = createNode({
            createPort(QShaderNodePort::Output, "value")
        });
        worldPosition.setUuid(QUuid("{00000000-0000-0000-0000-000000000001}"));
        worldPosition.setParameter("name", "worldPosition");
        worldPosition.setParameter("qualifier", QVariant::fromValue<QShaderLanguage::StorageQualifier>(QShaderLanguage::Input));
        worldPosition.setParameter("type", QVariant::fromValue<QShaderLanguage::VariableType>(QShaderLanguage::Vec3));
        worldPosition.addRule(openGLES2, QShaderNode::Rule("highp $type $value = $name;",
                                                           QByteArrayList() << "$qualifier highp $type $name;"));
        worldPosition.addRule(openGL3, QShaderNode::Rule("$type $value = $name;",
                                                         QByteArrayList() << "$qualifier $type $name;"));

        auto texture = createNode({
            createPort(QShaderNodePort::Output, "texture")
        });
        texture.setUuid(QUuid("{00000000-0000-0000-0000-000000000002}"));
        texture.addRule(openGLES2, QShaderNode::Rule("sampler2D $texture = texture;",
                                                     QByteArrayList() << "uniform sampler2D texture;"));
        texture.addRule(openGL3, QShaderNode::Rule("sampler2D $texture = texture;",
                                                   QByteArrayList() << "uniform sampler2D texture;"));

        auto texCoord = createNode({
            createPort(QShaderNodePort::Output, "texCoord")
        });
        texCoord.setUuid(QUuid("{00000000-0000-0000-0000-000000000003}"));
        texCoord.addRule(openGLES2, QShaderNode::Rule("highp vec2 $texCoord = texCoord;",
                                                      QByteArrayList() << "varying highp vec2 texCoord;"));
        texCoord.addRule(openGL3, QShaderNode::Rule("vec2 $texCoord = texCoord;",
                                                    QByteArrayList() << "in vec2 texCoord;"));

        auto lightIntensity = createNode({
            createPort(QShaderNodePort::Output, "value")
        });
        lightIntensity.setUuid(QUuid("{00000000-0000-0000-0000-000000000004}"));
        lightIntensity.setParameter("name", "defaultName");
        lightIntensity.setParameter("qualifier", QVariant::fromValue<QShaderLanguage::StorageQualifier>(QShaderLanguage::Uniform));
        lightIntensity.setParameter("type", QVariant::fromValue<QShaderLanguage::VariableType>(QShaderLanguage::Float));
        lightIntensity.addRule(openGLES2, QShaderNode::Rule("highp $type $value = $name;",
                                                            QByteArrayList() << "$qualifier highp $type $name;"));
        lightIntensity.addRule(openGL3, QShaderNode::Rule("$type $value = $name;",
                                                          QByteArrayList() << "$qualifier $type $name;"));

        auto exposure = createNode({
            createPort(QShaderNodePort::Output, "exposure")
        });
        exposure.setUuid(QUuid("{00000000-0000-0000-0000-000000000005}"));
        exposure.addRule(openGLES2, QShaderNode::Rule("highp float $exposure = exposure;",
                                                      QByteArrayList() << "uniform highp float exposure;"));
        exposure.addRule(openGL3, QShaderNode::Rule("float $exposure = exposure;",
                                                    QByteArrayList() << "uniform float exposure;"));

        auto fragColor = createNode({
            createPort(QShaderNodePort::Input, "fragColor")
        });
        fragColor.setUuid(QUuid("{00000000-0000-0000-0000-000000000006}"));
        fragColor.addRule(openGLES2, QShaderNode::Rule("gl_fragColor = $fragColor;"));
        fragColor.addRule(openGL3, QShaderNode::Rule("fragColor = $fragColor;",
                                                     QByteArrayList() << "out vec4 fragColor;"));

        auto sampleTexture = createNode({
            createPort(QShaderNodePort::Input, "sampler"),
            createPort(QShaderNodePort::Input, "coord"),
            createPort(QShaderNodePort::Output, "color")
        });
        sampleTexture.setUuid(QUuid("{00000000-0000-0000-0000-000000000007}"));
        sampleTexture.addRule(openGLES2, QShaderNode::Rule("highp vec4 $color = texture2D($sampler, $coord);"));
        sampleTexture.addRule(openGL3, QShaderNode::Rule("vec4 $color = texture2D($sampler, $coord);"));

        auto lightFunction = createNode({
            createPort(QShaderNodePort::Input, "baseColor"),
            createPort(QShaderNodePort::Input, "position"),
            createPort(QShaderNodePort::Input, "lightIntensity"),
            createPort(QShaderNodePort::Output, "outputColor")
        });
        lightFunction.setUuid(QUuid("{00000000-0000-0000-0000-000000000008}"));
        lightFunction.addRule(openGLES2, QShaderNode::Rule("highp vec4 $outputColor = lightModel($baseColor, $position, $lightIntensity);",
                                                           QByteArrayList() << "#pragma include es2/lightmodel.frag.inc"));
        lightFunction.addRule(openGL3, QShaderNode::Rule("vec4 $outputColor = lightModel($baseColor, $position, $lightIntensity);",
                                                         QByteArrayList() << "#pragma include gl3/lightmodel.frag.inc"));

        auto exposureFunction = createNode({
            createPort(QShaderNodePort::Input, "inputColor"),
            createPort(QShaderNodePort::Input, "exposure"),
            createPort(QShaderNodePort::Output, "outputColor")
        });
        exposureFunction.setUuid(QUuid("{00000000-0000-0000-0000-000000000009}"));
        exposureFunction.addRule(openGLES2, QShaderNode::Rule("highp vec4 $outputColor = $inputColor * pow(2.0, $exposure);"));
        exposureFunction.addRule(openGL3, QShaderNode::Rule("vec4 $outputColor = $inputColor * pow(2.0, $exposure);"));

        graph.addNode(worldPosition);
        graph.addNode(texture);
        graph.addNode(texCoord);
        graph.addNode(lightIntensity);
        graph.addNode(exposure);
        graph.addNode(fragColor);
        graph.addNode(sampleTexture);
        graph.addNode(lightFunction);
        graph.addNode(exposureFunction);

        graph.addEdge(createEdge(texture.uuid(), "texture", sampleTexture.uuid(), "sampler"));
        graph.addEdge(createEdge(texCoord.uuid(), "texCoord", sampleTexture.uuid(), "coord"));

        graph.addEdge(createEdge(worldPosition.uuid(), "value", lightFunction.uuid(), "position"));
        graph.addEdge(createEdge(sampleTexture.uuid(), "color", lightFunction.uuid(), "baseColor"));
        graph.addEdge(createEdge(lightIntensity.uuid(), "value", lightFunction.uuid(), "lightIntensity"));

        graph.addEdge(createEdge(lightFunction.uuid(), "outputColor", exposureFunction.uuid(), "inputColor"));
        graph.addEdge(createEdge(exposure.uuid(), "exposure", exposureFunction.uuid(), "exposure"));

        graph.addEdge(createEdge(exposureFunction.uuid(), "outputColor", fragColor.uuid(), "fragColor"));

        return graph;
    }

    void debugStatement(const QString &prefix, const QShaderGraph::Statement &statement)
    {
        qDebug() << prefix << statement.inputs << statement.uuid().toString() << statement.outputs;
    }

    void dumpStatementsIfNeeded(const QVector<QShaderGraph::Statement> &statements, const QVector<QShaderGraph::Statement> &expected)
    {
        if (statements != expected) {
            for (int i = 0; i < qMax(statements.size(), expected.size()); i++) {
                qDebug() << "----" << i << "----";
                if (i < statements.size())
                    debugStatement("A:", statements.at(i));
                if (i < expected.size())
                    debugStatement("E:", expected.at(i));
                qDebug() << "-----------";
            }
        }
    }
}

class tst_QShaderGraphLoader : public QObject
{
    Q_OBJECT
private slots:
    void shouldManipulateLoaderMembers();
    void shouldLoadFromJsonStream_data();
    void shouldLoadFromJsonStream();
};

void tst_QShaderGraphLoader::shouldManipulateLoaderMembers()
{
    // GIVEN
    auto loader = QShaderGraphLoader();

    // THEN (default state)
    QCOMPARE(loader.status(), QShaderGraphLoader::Null);
    QVERIFY(!loader.device());
    QVERIFY(loader.graph().nodes().isEmpty());
    QVERIFY(loader.graph().edges().isEmpty());
    QVERIFY(loader.prototypes().isEmpty());

    // WHEN
    auto device1 = createBuffer(QByteArray("..........."), QIODevice::NotOpen);
    loader.setDevice(device1.data());

    // THEN
    QCOMPARE(loader.status(), QShaderGraphLoader::Error);
    QCOMPARE(loader.device(), device1.data());
    QVERIFY(loader.graph().nodes().isEmpty());
    QVERIFY(loader.graph().edges().isEmpty());

    // WHEN
    auto device2 = createBuffer(QByteArray("..........."), QIODevice::ReadOnly);
    loader.setDevice(device2.data());

    // THEN
    QCOMPARE(loader.status(), QShaderGraphLoader::Waiting);
    QCOMPARE(loader.device(), device2.data());
    QVERIFY(loader.graph().nodes().isEmpty());
    QVERIFY(loader.graph().edges().isEmpty());


    // WHEN
    const auto prototypes = [this]{
        auto res = QHash<QString, QShaderNode>();
        res.insert("foo", createNode({}));
        return res;
    }();
    loader.setPrototypes(prototypes);

    // THEN
    QCOMPARE(loader.prototypes().size(), prototypes.size());
    QVERIFY(loader.prototypes().contains("foo"));
    QCOMPARE(loader.prototypes().value("foo").uuid(), prototypes.value("foo").uuid());
}

void tst_QShaderGraphLoader::shouldLoadFromJsonStream_data()
{
    QTest::addColumn<QBufferPointer>("device");
    QTest::addColumn<PrototypeHash>("prototypes");
    QTest::addColumn<QShaderGraph>("graph");
    QTest::addColumn<QShaderGraphLoader::Status>("status");

    QTest::newRow("empty") << createBuffer("", QIODevice::ReadOnly) << PrototypeHash()
                           << QShaderGraph() << QShaderGraphLoader::Error;

    const auto smallJson = "{"
                           "    \"nodes\": ["
                           "        {"
                           "            \"uuid\": \"{00000000-0000-0000-0000-000000000001}\","
                           "            \"type\": \"MyInput\","
                           "            \"layers\": [\"foo\", \"bar\"]"
                           "        },"
                           "        {"
                           "            \"uuid\": \"{00000000-0000-0000-0000-000000000002}\","
                           "            \"type\": \"MyOutput\""
                           "        },"
                           "        {"
                           "            \"uuid\": \"{00000000-0000-0000-0000-000000000003}\","
                           "            \"type\": \"MyFunction\""
                           "        }"
                           "    ],"
                           "    \"edges\": ["
                           "        {"
                           "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000001}\","
                           "            \"sourcePort\": \"input\","
                           "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000003}\","
                           "            \"targetPort\": \"functionInput\","
                           "            \"layers\": [\"bar\", \"baz\"]"
                           "        },"
                           "        {"
                           "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000003}\","
                           "            \"sourcePort\": \"functionOutput\","
                           "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000002}\","
                           "            \"targetPort\": \"output\""
                           "        }"
                           "    ]"
                           "}";

    const auto smallProtos = [this]{
        auto protos = PrototypeHash();

        auto input = createNode({
            createPort(QShaderNodePort::Output, "input")
        });
        protos.insert("MyInput", input);

        auto output = createNode({
            createPort(QShaderNodePort::Input, "output")
        });
        protos.insert("MyOutput", output);

        auto function = createNode({
            createPort(QShaderNodePort::Input, "functionInput"),
            createPort(QShaderNodePort::Output, "functionOutput")
        });
        protos.insert("MyFunction", function);
        return protos;
    }();

    const auto smallGraph = [this]{
        auto graph = QShaderGraph();

        auto input = createNode({
            createPort(QShaderNodePort::Output, "input")
        }, {"foo", "bar"});
        input.setUuid(QUuid("{00000000-0000-0000-0000-000000000001}"));
        auto output = createNode({
            createPort(QShaderNodePort::Input, "output")
        });
        output.setUuid(QUuid("{00000000-0000-0000-0000-000000000002}"));
        auto function = createNode({
            createPort(QShaderNodePort::Input, "functionInput"),
            createPort(QShaderNodePort::Output, "functionOutput")
        });
        function.setUuid(QUuid("{00000000-0000-0000-0000-000000000003}"));

        graph.addNode(input);
        graph.addNode(output);
        graph.addNode(function);
        graph.addEdge(createEdge(input.uuid(), "input", function.uuid(), "functionInput", {"bar", "baz"}));
        graph.addEdge(createEdge(function.uuid(), "functionOutput", output.uuid(), "output"));

        return graph;
    }();

    QTest::newRow("TwoNodesOneEdge") << createBuffer(smallJson) << smallProtos << smallGraph << QShaderGraphLoader::Ready;
    QTest::newRow("NotOpen") << createBuffer(smallJson, QIODevice::NotOpen) << smallProtos << QShaderGraph() << QShaderGraphLoader::Error;
    QTest::newRow("NoPrototype") << createBuffer(smallJson) << PrototypeHash() << QShaderGraph() << QShaderGraphLoader::Error;

    const auto complexJson = "{"
                             "    \"nodes\": ["
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000001}\","
                             "            \"type\": \"inputValue\","
                             "            \"parameters\": {"
                             "                \"name\": \"worldPosition\","
                             "                \"qualifier\": {"
                             "                    \"type\": \"QShaderLanguage::StorageQualifier\","
                             "                    \"value\": \"QShaderLanguage::Input\""
                             "                },"
                             "                \"type\": {"
                             "                    \"type\": \"QShaderLanguage::VariableType\","
                             "                    \"value\": \"QShaderLanguage::Vec3\""
                             "                }"
                             "            }"
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000002}\","
                             "            \"type\": \"texture\""
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000003}\","
                             "            \"type\": \"texCoord\""
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000004}\","
                             "            \"type\": \"inputValue\""
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000005}\","
                             "            \"type\": \"exposure\""
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000006}\","
                             "            \"type\": \"fragColor\""
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000007}\","
                             "            \"type\": \"sampleTexture\""
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000008}\","
                             "            \"type\": \"lightModel\""
                             "        },"
                             "        {"
                             "            \"uuid\": \"{00000000-0000-0000-0000-000000000009}\","
                             "            \"type\": \"exposureFunction\""
                             "        }"
                             "    ],"
                             "    \"edges\": ["
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000002}\","
                             "            \"sourcePort\": \"texture\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000007}\","
                             "            \"targetPort\": \"sampler\""
                             "        },"
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000003}\","
                             "            \"sourcePort\": \"texCoord\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000007}\","
                             "            \"targetPort\": \"coord\""
                             "        },"
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000001}\","
                             "            \"sourcePort\": \"value\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000008}\","
                             "            \"targetPort\": \"position\""
                             "        },"
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000007}\","
                             "            \"sourcePort\": \"color\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000008}\","
                             "            \"targetPort\": \"baseColor\""
                             "        },"
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000004}\","
                             "            \"sourcePort\": \"value\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000008}\","
                             "            \"targetPort\": \"lightIntensity\""
                             "        },"
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000008}\","
                             "            \"sourcePort\": \"outputColor\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000009}\","
                             "            \"targetPort\": \"inputColor\""
                             "        },"
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000005}\","
                             "            \"sourcePort\": \"exposure\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000009}\","
                             "            \"targetPort\": \"exposure\""
                             "        },"
                             "        {"
                             "            \"sourceUuid\": \"{00000000-0000-0000-0000-000000000009}\","
                             "            \"sourcePort\": \"outputColor\","
                             "            \"targetUuid\": \"{00000000-0000-0000-0000-000000000006}\","
                             "            \"targetPort\": \"fragColor\""
                             "        }"
                             "    ]"
                             "}";

    const auto complexProtos = [this]{
        const auto openGLES2 = createFormat(QShaderFormat::OpenGLES, 2, 0);
        const auto openGL3 = createFormat(QShaderFormat::OpenGLCoreProfile, 3, 0);

        auto protos = PrototypeHash();

        auto inputValue = createNode({
            createPort(QShaderNodePort::Output, "value")
        });
        inputValue.setParameter("name", "defaultName");
        inputValue.setParameter("qualifier", QVariant::fromValue<QShaderLanguage::StorageQualifier>(QShaderLanguage::Uniform));
        inputValue.setParameter("type", QVariant::fromValue<QShaderLanguage::VariableType>(QShaderLanguage::Float));
        inputValue.addRule(openGLES2, QShaderNode::Rule("highp $type $value = $name;",
                                                        QByteArrayList() << "$qualifier highp $type $name;"));
        inputValue.addRule(openGL3, QShaderNode::Rule("$type $value = $name;",
                                                      QByteArrayList() << "$qualifier $type $name;"));
        protos.insert("inputValue", inputValue);

        auto texture = createNode({
            createPort(QShaderNodePort::Output, "texture")
        });
        texture.addRule(openGLES2, QShaderNode::Rule("sampler2D $texture = texture;",
                                                     QByteArrayList() << "uniform sampler2D texture;"));
        texture.addRule(openGL3, QShaderNode::Rule("sampler2D $texture = texture;",
                                                   QByteArrayList() << "uniform sampler2D texture;"));
        protos.insert("texture", texture);

        auto texCoord = createNode({
            createPort(QShaderNodePort::Output, "texCoord")
        });
        texCoord.addRule(openGLES2, QShaderNode::Rule("highp vec2 $texCoord = texCoord;",
                                                      QByteArrayList() << "varying highp vec2 texCoord;"));
        texCoord.addRule(openGL3, QShaderNode::Rule("vec2 $texCoord = texCoord;",
                                                    QByteArrayList() << "in vec2 texCoord;"));
        protos.insert("texCoord", texCoord);

        auto exposure = createNode({
            createPort(QShaderNodePort::Output, "exposure")
        });
        exposure.addRule(openGLES2, QShaderNode::Rule("highp float $exposure = exposure;",
                                                      QByteArrayList() << "uniform highp float exposure;"));
        exposure.addRule(openGL3, QShaderNode::Rule("float $exposure = exposure;",
                                                    QByteArrayList() << "uniform float exposure;"));
        protos.insert("exposure", exposure);

        auto fragColor = createNode({
            createPort(QShaderNodePort::Input, "fragColor")
        });
        fragColor.addRule(openGLES2, QShaderNode::Rule("gl_fragColor = $fragColor;"));
        fragColor.addRule(openGL3, QShaderNode::Rule("fragColor = $fragColor;",
                                                     QByteArrayList() << "out vec4 fragColor;"));
        protos.insert("fragColor", fragColor);

        auto sampleTexture = createNode({
            createPort(QShaderNodePort::Input, "sampler"),
            createPort(QShaderNodePort::Input, "coord"),
            createPort(QShaderNodePort::Output, "color")
        });
        sampleTexture.addRule(openGLES2, QShaderNode::Rule("highp vec4 $color = texture2D($sampler, $coord);"));
        sampleTexture.addRule(openGL3, QShaderNode::Rule("vec4 $color = texture2D($sampler, $coord);"));
        protos.insert("sampleTexture", sampleTexture);

        auto lightModel = createNode({
            createPort(QShaderNodePort::Input, "baseColor"),
            createPort(QShaderNodePort::Input, "position"),
            createPort(QShaderNodePort::Input, "lightIntensity"),
            createPort(QShaderNodePort::Output, "outputColor")
        });
        lightModel.addRule(openGLES2, QShaderNode::Rule("highp vec4 $outputColor = lightModel($baseColor, $position, $lightIntensity);",
                                                        QByteArrayList() << "#pragma include es2/lightmodel.frag.inc"));
        lightModel.addRule(openGL3, QShaderNode::Rule("vec4 $outputColor = lightModel($baseColor, $position, $lightIntensity);",
                                                      QByteArrayList() << "#pragma include gl3/lightmodel.frag.inc"));
        protos.insert("lightModel", lightModel);

        auto exposureFunction = createNode({
            createPort(QShaderNodePort::Input, "inputColor"),
            createPort(QShaderNodePort::Input, "exposure"),
            createPort(QShaderNodePort::Output, "outputColor")
        });
        exposureFunction.addRule(openGLES2, QShaderNode::Rule("highp vec4 $outputColor = $inputColor * pow(2.0, $exposure);"));
        exposureFunction.addRule(openGL3, QShaderNode::Rule("vec4 $outputColor = $inputColor * pow(2.0, $exposure);"));
        protos.insert("exposureFunction", exposureFunction);

        return protos;
    }();

    const auto complexGraph = createGraph();

    QTest::newRow("ComplexGraph") << createBuffer(complexJson) << complexProtos << complexGraph << QShaderGraphLoader::Ready;
}

void tst_QShaderGraphLoader::shouldLoadFromJsonStream()
{
    // GIVEN
    QFETCH(QBufferPointer, device);
    QFETCH(PrototypeHash, prototypes);

    auto loader = QShaderGraphLoader();

    // WHEN
    loader.setPrototypes(prototypes);
    loader.setDevice(device.data());
    loader.load();

    // THEN
    QFETCH(QShaderGraphLoader::Status, status);
    QCOMPARE(loader.status(), status);

    QFETCH(QShaderGraph, graph);
    const auto statements = loader.graph().createStatements({"foo", "bar", "baz"});
    const auto expected = graph.createStatements({"foo", "bar", "baz"});
    dumpStatementsIfNeeded(statements, expected);
    QCOMPARE(statements, expected);

    const auto sortedParameters = [](const QShaderNode &node) {
        auto res = node.parameterNames();
        res.sort();
        return res;
    };

    for (int i = 0; i < statements.size(); i++) {
        const auto actualNode = statements.at(i).node;
        const auto expectedNode = expected.at(i).node;

        QCOMPARE(actualNode.layers(), expectedNode.layers());
        QCOMPARE(actualNode.ports(), expectedNode.ports());
        QCOMPARE(sortedParameters(actualNode), sortedParameters(expectedNode));
        for (const auto &name : expectedNode.parameterNames()) {
            QCOMPARE(actualNode.parameter(name), expectedNode.parameter(name));
        }
        QCOMPARE(actualNode.availableFormats(), expectedNode.availableFormats());
        for (const auto &format : expectedNode.availableFormats()) {
            QCOMPARE(actualNode.rule(format), expectedNode.rule(format));
        }
    }
}

QTEST_MAIN(tst_QShaderGraphLoader)

#include "tst_qshadergraphloader.moc"