/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2017 The Khronos Group Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * \file  glcShaderConstExprTests.cpp
 * \brief Declares shader constant expressions tests.
 */ /*-------------------------------------------------------------------*/

#include <map>
#include "deMath.h"
#include "deSharedPtr.hpp"
#include "glcShaderConstExprTests.hpp"
#include "glsShaderExecUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluShaderUtil.hpp"
#include "tcuFloat.hpp"
#include "tcuStringTemplate.hpp"
#include "tcuTestLog.hpp"

using namespace deqp::gls::ShaderExecUtil;

namespace glcts
{

namespace ShaderConstExpr
{

struct TestParams
{
    const char *name;
    const char *expression;

    glu::DataType inType;
    int minComponents;
    int maxComponents;

    glu::DataType outType;
    union
    {
        float outputFloat;
        int outputInt;
    };
};

struct ShaderExecutorParams
{
    deqp::Context *context;

    std::string caseName;
    std::string source;

    glu::DataType outType;
    union
    {
        float outputFloat;
        int outputInt;
    };
};

template <typename OutputType>
class ExecutorTestCase : public deqp::TestCase
{
  public:
    ExecutorTestCase(deqp::Context &context,
                     const char *name,
                     glu::ShaderType shaderType,
                     const ShaderSpec &shaderSpec,
                     OutputType expectedOutput);
    virtual ~ExecutorTestCase(void);
    virtual tcu::TestNode::IterateResult iterate(void);

  protected:
    void validateOutput(de::SharedPtr<ShaderExecutor> executor);

    glu::ShaderType m_shaderType;
    ShaderSpec m_shaderSpec;
    OutputType m_expectedOutput;
};

template <typename OutputType>
ExecutorTestCase<OutputType>::ExecutorTestCase(deqp::Context &context,
                                               const char *name,
                                               glu::ShaderType shaderType,
                                               const ShaderSpec &shaderSpec,
                                               OutputType expectedOutput)
    : deqp::TestCase(context, name, ""),
      m_shaderType(shaderType),
      m_shaderSpec(shaderSpec),
      m_expectedOutput(expectedOutput)
{}

template <typename OutputType>
ExecutorTestCase<OutputType>::~ExecutorTestCase(void)
{}

template <>
void ExecutorTestCase<float>::validateOutput(de::SharedPtr<ShaderExecutor> executor)
{
    float result        = 0.0f;
    void *const outputs = &result;
    executor->execute(1, DE_NULL, &outputs);

    const float epsilon = 0.01f;
    if (de::abs(m_expectedOutput - result) > epsilon)
    {
        m_context.getTestContext().getLog()
            << tcu::TestLog::Message << "Expected: " << m_expectedOutput << " ("
            << tcu::toHex(tcu::Float32(m_expectedOutput).bits())
            << ") but constant expresion returned: " << result << " ("
            << tcu::toHex(tcu::Float32(result).bits()) << "), used " << epsilon
            << " epsilon for comparison" << tcu::TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
        return;
    }

    m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    return;
}

template <>
void ExecutorTestCase<int>::validateOutput(de::SharedPtr<ShaderExecutor> executor)
{
    int result          = 0;
    void *const outputs = &result;
    executor->execute(1, DE_NULL, &outputs);

    if (result == m_expectedOutput)
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
        return;
    }

    m_context.getTestContext().getLog()
        << tcu::TestLog::Message << "Expected: " << m_expectedOutput
        << " but constant expresion returned: " << result << tcu::TestLog::EndMessage;
    m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}

template <typename OutputType>
tcu::TestNode::IterateResult ExecutorTestCase<OutputType>::iterate(void)
{
    de::SharedPtr<ShaderExecutor> executor(
        createExecutor(m_context.getRenderContext(), m_shaderType, m_shaderSpec));

    DE_ASSERT(executor.get());

    executor->log(m_context.getTestContext().getLog());

    try
    {
        if (!executor->isOk())
            TCU_FAIL("Compilation failed");

        executor->useProgram();

        validateOutput(executor);
    }
    catch (const tcu::NotSupportedError &e)
    {
        m_testCtx.getLog() << tcu::TestLog::Message << e.what() << tcu::TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, e.getMessage());
    }
    catch (const tcu::TestError &e)
    {
        m_testCtx.getLog() << tcu::TestLog::Message << e.what() << tcu::TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, e.getMessage());
    }

    return tcu::TestNode::STOP;
}

template <typename OutputType>
void createTestCasesForAllShaderTypes(const ShaderExecutorParams &params,
                                      std::vector<tcu::TestNode *> &outputTests)
{
    DE_ASSERT(params.context);

    deqp::Context &context       = *(params.context);
    glu::ContextType contextType = context.getRenderContext().getType();

    ShaderSpec shaderSpec;
    shaderSpec.version = glu::getContextTypeGLSLVersion(contextType);
    shaderSpec.source  = params.source;
    shaderSpec.outputs.push_back(
        Symbol("out0", glu::VarType(params.outType, glu::PRECISION_HIGHP)));

    // Construct list of shaders for which tests can be created
    std::vector<glu::ShaderType> shaderTypes;

    if (glu::contextSupports(contextType, glu::ApiType::core(4, 3)))
    {
        shaderTypes.push_back(glu::SHADERTYPE_VERTEX);
        shaderTypes.push_back(glu::SHADERTYPE_FRAGMENT);
        shaderTypes.push_back(glu::SHADERTYPE_COMPUTE);
        shaderTypes.push_back(glu::SHADERTYPE_GEOMETRY);
        shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_CONTROL);
        shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_EVALUATION);
    }
    else if (glu::contextSupports(contextType, glu::ApiType::es(3, 2)))
    {
        shaderSpec.version = glu::GLSL_VERSION_320_ES;
        shaderTypes.push_back(glu::SHADERTYPE_GEOMETRY);
        shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_CONTROL);
        shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_EVALUATION);
    }
    else if (glu::contextSupports(contextType, glu::ApiType::es(3, 1)))
    {
        shaderSpec.version = glu::GLSL_VERSION_310_ES;
        shaderTypes.push_back(glu::SHADERTYPE_COMPUTE);
        shaderTypes.push_back(glu::SHADERTYPE_GEOMETRY);
        shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_CONTROL);
        shaderTypes.push_back(glu::SHADERTYPE_TESSELLATION_EVALUATION);
    }
    else
    {
        shaderTypes.push_back(glu::SHADERTYPE_VERTEX);
        shaderTypes.push_back(glu::SHADERTYPE_FRAGMENT);
    }

    shaderSpec.globalDeclarations += "precision highp float;\n";

    for (std::size_t typeIndex = 0; typeIndex < shaderTypes.size(); ++typeIndex)
    {
        glu::ShaderType shaderType = shaderTypes[typeIndex];
        std::string caseName(params.caseName + '_' + getShaderTypeName(shaderType));

        outputTests.push_back(
            new ExecutorTestCase<OutputType>(context, caseName.c_str(), shaderType, shaderSpec,
                                             static_cast<OutputType>(params.outputFloat)));
    }
}

void createTests(deqp::Context &context,
                 const TestParams *cases,
                 int numCases,
                 const char *shaderTemplateSrc,
                 const char *casePrefix,
                 std::vector<tcu::TestNode *> &outputTests)
{
    const tcu::StringTemplate shaderTemplate(shaderTemplateSrc);
    const char *componentAccess[] = {"", ".y", ".z", ".w"};

    ShaderExecutorParams shaderExecutorParams;
    shaderExecutorParams.context = &context;

    for (int caseIndex = 0; caseIndex < numCases; caseIndex++)
    {
        const TestParams &testCase   = cases[caseIndex];
        const std::string baseName   = testCase.name;
        const int minComponents      = testCase.minComponents;
        const int maxComponents      = testCase.maxComponents;
        const glu::DataType inType   = testCase.inType;
        const std::string expression = testCase.expression;

        // Check for presence of func(vec, scalar) style specialization,
        // use as gatekeeper for applying said specialization
        const bool alwaysScalar = expression.find("${MT}") != std::string::npos;

        std::map<std::string, std::string> shaderTemplateParams;
        shaderTemplateParams["CASE_BASE_TYPE"] = glu::getDataTypeName(testCase.outType);

        shaderExecutorParams.outType     = testCase.outType;
        shaderExecutorParams.outputFloat = testCase.outputFloat;

        for (int component = minComponents - 1; component < maxComponents; component++)
        {
            // Get type name eg. float, vec2, vec3, vec4 (same for other primitive types)
            glu::DataType dataType = static_cast<glu::DataType>(inType + component);
            std::string typeName   = glu::getDataTypeName(dataType);

            // ${T} => final type, ${MT} => final type but with scalar version usable even when T is
            // a vector
            std::map<std::string, std::string> expressionTemplateParams;
            expressionTemplateParams["T"]  = typeName;
            expressionTemplateParams["MT"] = typeName;

            const tcu::StringTemplate expressionTemplate(expression);

            // Add vector access to expression as needed
            shaderTemplateParams["CASE_EXPRESSION"] =
                expressionTemplate.specialize(expressionTemplateParams) +
                componentAccess[component];

            {
                // Add type to case name if we are generating multiple versions
                shaderExecutorParams.caseName = (casePrefix + baseName);
                if (minComponents != maxComponents)
                    shaderExecutorParams.caseName += ("_" + typeName);

                shaderExecutorParams.source = shaderTemplate.specialize(shaderTemplateParams);
                if (shaderExecutorParams.outType == glu::TYPE_FLOAT)
                    createTestCasesForAllShaderTypes<float>(shaderExecutorParams, outputTests);
                else
                    createTestCasesForAllShaderTypes<int>(shaderExecutorParams, outputTests);
            }

            // Deal with functions that allways accept one ore more scalar parameters even when
            // others are vectors
            if (alwaysScalar && component > 0)
            {
                shaderExecutorParams.caseName =
                    casePrefix + baseName + "_" + typeName + "_" + glu::getDataTypeName(inType);

                expressionTemplateParams["MT"] = glu::getDataTypeName(inType);
                shaderTemplateParams["CASE_EXPRESSION"] =
                    expressionTemplate.specialize(expressionTemplateParams) +
                    componentAccess[component];

                shaderExecutorParams.source = shaderTemplate.specialize(shaderTemplateParams);
                if (shaderExecutorParams.outType == glu::TYPE_FLOAT)
                    createTestCasesForAllShaderTypes<float>(shaderExecutorParams, outputTests);
                else
                    createTestCasesForAllShaderTypes<int>(shaderExecutorParams, outputTests);
            }
        }  // component loop
    }
}

}  // namespace ShaderConstExpr

ShaderConstExprTests::ShaderConstExprTests(deqp::Context &context)
    : deqp::TestCaseGroup(context, "constant_expressions", "Constant expressions")
{}

ShaderConstExprTests::~ShaderConstExprTests(void) {}

void ShaderConstExprTests::init(void)
{
    // Needed for autogenerating shader code for increased component counts
    DE_STATIC_ASSERT(glu::TYPE_FLOAT + 1 == glu::TYPE_FLOAT_VEC2);
    DE_STATIC_ASSERT(glu::TYPE_FLOAT + 2 == glu::TYPE_FLOAT_VEC3);
    DE_STATIC_ASSERT(glu::TYPE_FLOAT + 3 == glu::TYPE_FLOAT_VEC4);

    DE_STATIC_ASSERT(glu::TYPE_INT + 1 == glu::TYPE_INT_VEC2);
    DE_STATIC_ASSERT(glu::TYPE_INT + 2 == glu::TYPE_INT_VEC3);
    DE_STATIC_ASSERT(glu::TYPE_INT + 3 == glu::TYPE_INT_VEC4);

    DE_STATIC_ASSERT(glu::TYPE_UINT + 1 == glu::TYPE_UINT_VEC2);
    DE_STATIC_ASSERT(glu::TYPE_UINT + 2 == glu::TYPE_UINT_VEC3);
    DE_STATIC_ASSERT(glu::TYPE_UINT + 3 == glu::TYPE_UINT_VEC4);

    DE_STATIC_ASSERT(glu::TYPE_BOOL + 1 == glu::TYPE_BOOL_VEC2);
    DE_STATIC_ASSERT(glu::TYPE_BOOL + 2 == glu::TYPE_BOOL_VEC3);
    DE_STATIC_ASSERT(glu::TYPE_BOOL + 3 == glu::TYPE_BOOL_VEC4);

    // ${T} => final type, ${MT} => final type but with scalar version usable even when T is a
    // vector
    const ShaderConstExpr::TestParams baseCases[] = {
        {"radians",
         "radians(${T} (90.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {deFloatRadians(90.0f)}},
        {"degrees",
         "degrees(${T} (2.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {deFloatDegrees(2.0f)}},
        {"sin", "sin(${T} (3.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatSin(3.0f)}},
        {"cos", "cos(${T} (3.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatCos(3.2f)}},
        {"asin", "asin(${T} (0.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatAsin(0.0f)}},
        {"acos", "acos(${T} (1.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatAcos(1.0f)}},
        {"pow",
         "pow(${T} (1.7), ${T} (3.5))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {deFloatPow(1.7f, 3.5f)}},
        {"exp", "exp(${T} (4.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatExp(4.2f)}},
        {"log", "log(${T} (42.12))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatLog(42.12f)}},
        {"exp2", "exp2(${T} (6.7))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatExp2(6.7f)}},
        {"log2",
         "log2(${T} (100.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {deFloatLog2(100.0f)}},
        {"sqrt", "sqrt(${T} (10.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatSqrt(10.0f)}},
        {"inversesqrt",
         "inversesqrt(${T} (10.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {deFloatRsq(10.0f)}},
        {"abs", "abs(${T} (-42))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, {42}},
        {"sign", "sign(${T} (-18.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {-1.0f}},
        {"floor",
         "floor(${T} (37.3))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {deFloatFloor(37.3f)}},
        {"trunc", "trunc(${T} (-1.8))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {-1.0f}},
        {"round", "round(${T} (42.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {42.0f}},
        {"ceil", "ceil(${T} (82.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {deFloatCeil(82.2f)}},
        {"mod",
         "mod(${T} (87.65), ${MT} (3.7))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {deFloatMod(87.65f, 3.7f)}},
        {"min", "min(${T} (12.3), ${MT} (32.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {12.3f}},
        {"max", "max(${T} (12.3), ${MT} (32.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_FLOAT, {32.1f}},
        {"clamp",
         "clamp(${T} (42.1),	${MT} (10.0), ${MT} (15.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_FLOAT,
         {15.0f}},
        {"length_float", "length(1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, {1.0f}},
        {"length_vec2",
         "length(vec2(1.0))",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_FLOAT,
         {deFloatSqrt(2.0f)}},
        {"length_vec3",
         "length(vec3(1.0))",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_FLOAT,
         {deFloatSqrt(3.0f)}},
        {"length_vec4",
         "length(vec4(1.0))",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_FLOAT,
         {deFloatSqrt(4.0f)}},
        {"dot_float", "dot(1.0, 1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, {1.0f}},
        {"dot_vec2", "dot(vec2(1.0), vec2(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, {2.0f}},
        {"dot_vec3", "dot(vec3(1.0), vec3(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, {3.0f}},
        {"dot_vec4", "dot(vec4(1.0), vec4(1.0))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, {4.0f}},
        {"normalize_float", "normalize(1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_FLOAT, {1.0f}},
        {"normalize_vec2",
         "normalize(vec2(1.0)).x",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_FLOAT,
         {deFloatRsq(2.0f)}},
        {"normalize_vec3",
         "normalize(vec3(1.0)).x",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_FLOAT,
         {deFloatRsq(3.0f)}},
        {"normalize_vec4",
         "normalize(vec4(1.0)).x",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_FLOAT,
         {deFloatRsq(4.0f)}},
    };

    const ShaderConstExpr::TestParams arrayCases[] = {
        {"radians",
         "radians(${T} (60.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {deFloatRadians(60.0f)}},
        {"degrees",
         "degrees(${T} (0.11))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {deFloatDegrees(0.11f)}},
        {"sin",
         "${T} (1.0) + sin(${T} (0.7))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {1.0f + deFloatSin(0.7f)}},
        {"cos",
         "${T} (1.0) + cos(${T} (0.7))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {1.0f + deFloatCos(0.7f)}},
        {"asin", "asin(${T} (0.9))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatAsin(0.9f)}},
        {"acos", "acos(${T} (-0.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatAcos(-0.5f)}},
        {"pow",
         "pow(${T} (2.0), ${T} (2.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {deFloatPow(2.0f, 2.0f)}},
        {"exp", "exp(${T} (1.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatExp(1.2f)}},
        {"log", "log(${T} (8.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatLog(8.0f)}},
        {"exp2", "exp2(${T} (2.1))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatExp2(2.1f)}},
        {"log2", "log2(${T} (9.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatLog2(9.0)}},
        {"sqrt", "sqrt(${T} (4.5))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatSqrt(4.5f)}},
        {"inversesqrt",
         "inversesqrt(${T} (0.26))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {deFloatRsq(0.26f)}},
        {"abs", "abs(${T} (-2))", glu::TYPE_INT, 1, 4, glu::TYPE_INT, {2}},
        {"sign", "sign(${T} (18.0))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatSign(18.0f)}},
        {"floor", "floor(${T} (3.3))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatFloor(3.3f)}},
        {"trunc", "trunc(${T} (2.8))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {2}},
        {"round", "round(${T} (2.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatRound(2.2f)}},
        {"ceil", "ceil(${T} (2.2))", glu::TYPE_FLOAT, 1, 4, glu::TYPE_INT, {deFloatCeil(2.2f)}},
        {"mod",
         "mod(${T} (7.1), ${MT} (4.0))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {deFloatMod(7.1f, 4.0f)}},
        {"min",
         "min(${T} (2.3), ${MT} (3.1))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {deFloatMin(2.3f, 3.1f)}},
        {"max",
         "max(${T} (2.3), ${MT} (3.1))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {deFloatMax(2.3f, 3.1f)}},
        {"clamp",
         "clamp(${T} (4.1),	${MT} (2.1), ${MT} (3.1))",
         glu::TYPE_FLOAT,
         1,
         4,
         glu::TYPE_INT,
         {3}},
        {"length_float", "length(2.1)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, {2}},
        {"length_vec2",
         "length(vec2(1.0))",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_INT,
         {deFloatSqrt(2.0f)}},
        {"length_vec3",
         "length(vec3(1.0))",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_INT,
         {deFloatSqrt(3.0f)}},
        {"length_vec4",
         "length(vec4(1.0))",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_INT,
         {deFloatSqrt(4.0f)}},
        {"dot_float", "dot(1.0, 1.0)", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, {1}},
        {"dot_vec2", "dot(vec2(1.0), vec2(1.01))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, {2}},
        {"dot_vec3", "dot(vec3(1.0), vec3(1.1))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, {3}},
        {"dot_vec4", "dot(vec4(1.0), vec4(1.1))", glu::TYPE_FLOAT, 1, 1, glu::TYPE_INT, {4}},
        {"normalize_float",
         "${T} (1.0) + normalize(2.0)",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_INT,
         {2}},
        {"normalize_vec2",
         "${T} (1.0) + normalize(vec2(1.0)).x",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_INT,
         {1.0f + deFloatRsq(2.0f)}},
        {"normalize_vec3",
         "${T} (1.0) + normalize(vec3(1.0)).x",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_INT,
         {1.0f + deFloatRsq(3.0f)}},
        {"normalize_vec4",
         "${T} (1.0) + normalize(vec4(1.0)).x",
         glu::TYPE_FLOAT,
         1,
         1,
         glu::TYPE_INT,
         {1.0f + deFloatRsq(4.0f)}},
    };

    const char *basicShaderTemplate =
        "const ${CASE_BASE_TYPE} cval = ${CASE_EXPRESSION};\n"
        "out0 = cval;\n";

    std::vector<tcu::TestNode *> children;
    ShaderConstExpr::createTests(m_context, baseCases, DE_LENGTH_OF_ARRAY(baseCases),
                                 basicShaderTemplate, "basic_", children);

    const char *arrayShaderTemplate =
        "float array[int(${CASE_EXPRESSION})];\n"
        "out0 = array.length();\n";

    ShaderConstExpr::createTests(m_context, arrayCases, DE_LENGTH_OF_ARRAY(arrayCases),
                                 arrayShaderTemplate, "array_", children);

    for (std::size_t i = 0; i < children.size(); i++)
        addChild(children[i]);
}

}  // namespace glcts
