/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.1 Module
 * -------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * 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
 * \brief Explicit uniform location tests
 *//*--------------------------------------------------------------------*/

#include "es31fUniformLocationTests.hpp"

#include "tcuTestLog.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuVectorUtil.hpp"
#include "tcuCommandLine.hpp"

#include "glsShaderLibrary.hpp"
#include "glsTextureTestUtil.hpp"

#include "gluShaderProgram.hpp"
#include "gluTexture.hpp"
#include "gluPixelTransfer.hpp"
#include "gluVarType.hpp"
#include "gluVarTypeUtil.hpp"

#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "sglrContextUtil.hpp"

#include "deStringUtil.hpp"
#include "deUniquePtr.hpp"
#include "deString.h"
#include "deRandom.hpp"
#include "deInt32.h"

#include <set>
#include <map>

namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{

using de::UniquePtr;
using glu::VarType;
using std::map;
using std::string;
using std::vector;

struct UniformInfo
{
    enum ShaderStage
    {
        SHADERSTAGE_NONE     = 0,
        SHADERSTAGE_VERTEX   = (1 << 0),
        SHADERSTAGE_FRAGMENT = (1 << 1),
        SHADERSTAGE_BOTH     = (SHADERSTAGE_VERTEX | SHADERSTAGE_FRAGMENT),
    };

    VarType type;
    ShaderStage declareLocation; // support declarations with/without layout qualifiers, needed for linkage testing
    ShaderStage layoutLocation;
    ShaderStage checkLocation;
    int location; // -1 for unset

    UniformInfo(VarType type_, ShaderStage declareLocation_, ShaderStage layoutLocation_, ShaderStage checkLocation_,
                int location_ = -1)
        : type(type_)
        , declareLocation(declareLocation_)
        , layoutLocation(layoutLocation_)
        , checkLocation(checkLocation_)
        , location(location_)
    {
    }
};

class UniformLocationCase : public tcu::TestCase
{
public:
    UniformLocationCase(tcu::TestContext &context, glu::RenderContext &renderContext, const char *name,
                        const char *desc, const vector<UniformInfo> &uniformInfo);
    virtual ~UniformLocationCase(void)
    {
    }

    virtual IterateResult iterate(void);

protected:
    IterateResult run(const vector<UniformInfo> &uniformList);
    static glu::ProgramSources genShaderSources(const vector<UniformInfo> &uniformList);
    bool verifyLocations(const glu::ShaderProgram &program, const vector<UniformInfo> &uniformList);
    void render(const glu::ShaderProgram &program, const vector<UniformInfo> &uniformList);
    static bool verifyResult(const tcu::ConstPixelBufferAccess &access);

    static float getExpectedValue(glu::DataType type, int id, const char *name);

    de::MovePtr<glu::Texture2D> createTexture(glu::DataType samplerType, float redChannelValue, int binding);

    glu::RenderContext &m_renderCtx;

    const vector<UniformInfo> m_uniformInfo;

    enum
    {
        RENDER_SIZE = 16
    };
};

string getUniformName(int ndx, const glu::VarType &type, const glu::TypeComponentVector &path)
{
    std::ostringstream buff;
    buff << "uni" << ndx << glu::TypeAccessFormat(type, path);

    return buff.str();
}

string getFirstComponentName(const glu::VarType &type)
{
    std::ostringstream buff;
    if (glu::isDataTypeVector(type.getBasicType()))
        buff << glu::TypeAccessFormat(type, glu::SubTypeAccess(type).component(0).getPath());
    else if (glu::isDataTypeMatrix(type.getBasicType()))
        buff << glu::TypeAccessFormat(type, glu::SubTypeAccess(type).column(0).component(0).getPath());

    return buff.str();
}

UniformLocationCase::UniformLocationCase(tcu::TestContext &context, glu::RenderContext &renderContext, const char *name,
                                         const char *desc, const vector<UniformInfo> &uniformInfo)
    : TestCase(context, name, desc)
    , m_renderCtx(renderContext)
    , m_uniformInfo(uniformInfo)
{
}

// [from, to]
std::vector<int> shuffledRange(int from, int to, int seed)
{
    const int count = to - from;

    vector<int> retval(count);
    de::Random rng(seed);

    DE_ASSERT(count > 0);

    for (int ndx = 0; ndx < count; ndx++)
        retval[ndx] = ndx + from;

    rng.shuffle(retval.begin(), retval.end());
    return retval;
}

glu::DataType getDataTypeSamplerSampleType(glu::DataType type)
{
    using namespace glu;

    if (type >= TYPE_SAMPLER_1D && type <= TYPE_SAMPLER_3D)
        return TYPE_FLOAT_VEC4;
    else if (type >= TYPE_INT_SAMPLER_1D && type <= TYPE_INT_SAMPLER_3D)
        return TYPE_INT_VEC4;
    else if (type >= TYPE_UINT_SAMPLER_1D && type <= TYPE_UINT_SAMPLER_3D)
        return TYPE_UINT_VEC4;
    else if (type >= TYPE_SAMPLER_1D_SHADOW && type <= TYPE_SAMPLER_2D_ARRAY_SHADOW)
        return TYPE_FLOAT;
    else
        DE_FATAL("Unknown sampler type");

    return TYPE_INVALID;
}

// A (hopefully) unique value for a uniform. For multi-component types creates only one value. Values are in the range [0,1] for floats, [-128, 127] for ints, [0,255] for uints and 0/1 for booleans. Samplers are treated according to the types they return.
float UniformLocationCase::getExpectedValue(glu::DataType type, int id, const char *name)
{
    const uint32_t hash = deStringHash(name) + deInt32Hash(id);

    glu::DataType adjustedType = type;

    if (glu::isDataTypeSampler(type))
        adjustedType = getDataTypeSamplerSampleType(type);

    if (glu::isDataTypeIntOrIVec(adjustedType))
        return float(hash % 128);
    else if (glu::isDataTypeUintOrUVec(adjustedType))
        return float(hash % 255);
    else if (glu::isDataTypeFloatOrVec(adjustedType))
        return float(hash % 255) / 255.0f;
    else if (glu::isDataTypeBoolOrBVec(adjustedType))
        return float(hash % 2);
    else
        DE_FATAL("Unkown primitive type");

    return glu::TYPE_INVALID;
}

UniformLocationCase::IterateResult UniformLocationCase::iterate(void)
{
    return run(m_uniformInfo);
}

UniformLocationCase::IterateResult UniformLocationCase::run(const vector<UniformInfo> &uniformList)
{
    using gls::TextureTestUtil::RandomViewport;

    const glu::ProgramSources sources = genShaderSources(uniformList);
    const glu::ShaderProgram program(m_renderCtx, sources);
    const int baseSeed       = m_testCtx.getCommandLine().getBaseSeed();
    const glw::Functions &gl = m_renderCtx.getFunctions();
    const RandomViewport viewport(m_renderCtx.getRenderTarget(), RENDER_SIZE, RENDER_SIZE,
                                  deStringHash(getName()) + baseSeed);

    tcu::Surface rendered(RENDER_SIZE, RENDER_SIZE);

    if (!verifyLocations(program, uniformList))
        return STOP;

    gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
    gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);

    render(program, uniformList);

    glu::readPixels(m_renderCtx, viewport.x, viewport.y, rendered.getAccess());
    GLU_EXPECT_NO_ERROR(gl.getError(), "error in readPixels");

    if (!verifyResult(rendered.getAccess()))
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader produced incorrect result");
        return STOP;
    }

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

glu::ProgramSources UniformLocationCase::genShaderSources(const vector<UniformInfo> &uniformList)
{
    std::ostringstream vertDecl, vertMain, fragDecl, fragMain;

    vertDecl << "#version 310 es\n"
             << "precision highp float;\n"
             << "precision highp int;\n"
             << "float verify(float val, float ref) { return float(abs(val-ref) < 0.05); }\n\n"
             << "in highp vec4 a_position;\n"
             << "out highp vec4 v_color;\n";
    fragDecl << "#version 310 es\n\n"
             << "precision highp float;\n"
             << "precision highp int;\n"
             << "float verify(float val, float ref) { return float(abs(val-ref) < 0.05); }\n\n"
             << "in highp vec4 v_color;\n"
             << "layout(location = 0) out mediump vec4 o_color;\n\n";

    vertMain << "void main()\n{\n"
             << "    gl_Position = a_position;\n"
             << "    v_color = vec4(1.0);\n";

    fragMain << "void main()\n{\n"
             << "    o_color = v_color;\n";

    std::set<const glu::StructType *> declaredStructs;

    // Declare uniforms
    for (int uniformNdx = 0; uniformNdx < int(uniformList.size()); uniformNdx++)
    {
        const UniformInfo &uniformInfo = uniformList[uniformNdx];

        const bool declareInVert = (uniformInfo.declareLocation & UniformInfo::SHADERSTAGE_VERTEX) != 0;
        const bool declareInFrag = (uniformInfo.declareLocation & UniformInfo::SHADERSTAGE_FRAGMENT) != 0;
        const bool layoutInVert  = (uniformInfo.layoutLocation & UniformInfo::SHADERSTAGE_VERTEX) != 0;
        const bool layoutInFrag  = (uniformInfo.layoutLocation & UniformInfo::SHADERSTAGE_FRAGMENT) != 0;
        const bool checkInVert   = (uniformInfo.checkLocation & UniformInfo::SHADERSTAGE_VERTEX) != 0;
        const bool checkInFrag   = (uniformInfo.checkLocation & UniformInfo::SHADERSTAGE_FRAGMENT) != 0;

        const string layout =
            uniformInfo.location >= 0 ? "layout(location = " + de::toString(uniformInfo.location) + ") " : "";
        const string uniName = "uni" + de::toString(uniformNdx);

        int location     = uniformInfo.location;
        int subTypeIndex = 0;

        DE_ASSERT((declareInVert && layoutInVert) || !layoutInVert); // Cannot have layout without declaration
        DE_ASSERT((declareInFrag && layoutInFrag) || !layoutInFrag);
        DE_ASSERT(location < 0 || (layoutInVert || layoutInFrag)); // Cannot have location without layout

        // struct definitions
        if (uniformInfo.type.isStructType())
        {
            const glu::StructType *const structType = uniformInfo.type.getStructPtr();
            if (!declaredStructs.count(structType))
            {
                if (declareInVert)
                    vertDecl << glu::declare(structType, 0) << ";\n";

                if (declareInFrag)
                    fragDecl << glu::declare(structType, 0) << ";\n";

                declaredStructs.insert(structType);
            }
        }

        if (declareInVert)
            vertDecl << "uniform " << (layoutInVert ? layout : "") << glu::declare(uniformInfo.type, uniName) << ";\n";

        if (declareInFrag)
            fragDecl << "uniform " << (layoutInFrag ? layout : "") << glu::declare(uniformInfo.type, uniName) << ";\n";

        // Anything that needs to be done for each enclosed primitive type
        for (glu::BasicTypeIterator subTypeIter = glu::BasicTypeIterator::begin(&uniformInfo.type);
             subTypeIter != glu::BasicTypeIterator::end(&uniformInfo.type); subTypeIter++, subTypeIndex++)
        {
            const glu::VarType subType     = glu::getVarType(uniformInfo.type, subTypeIter.getPath());
            const glu::DataType scalarType = glu::getDataTypeScalarType(subType.getBasicType());
            const char *const typeName     = glu::getDataTypeName(scalarType);
            const string expectValue       = de::floatToString(
                getExpectedValue(scalarType, location >= 0 ? location + subTypeIndex : -1, typeName), 3);

            if (glu::isDataTypeSampler(scalarType))
            {
                if (checkInVert)
                    vertMain << "    v_color.rgb *= verify(float( texture(" << uniName
                             << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath()) << ", vec2(0.5)).r), "
                             << expectValue << ");\n";
                if (checkInFrag)
                    fragMain << "    o_color.rgb *= verify(float( texture(" << uniName
                             << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath()) << ", vec2(0.5)).r), "
                             << expectValue << ");\n";
            }
            else
            {
                if (checkInVert)
                    vertMain << "    v_color.rgb *= verify(float(" << uniName
                             << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath())
                             << getFirstComponentName(subType) << "), " << expectValue << ");\n";
                if (checkInFrag)
                    fragMain << "    o_color.rgb *= verify(float(" << uniName
                             << glu::TypeAccessFormat(uniformInfo.type, subTypeIter.getPath())
                             << getFirstComponentName(subType) << "), " << expectValue << ");\n";
            }
        }
    }

    vertMain << "}\n";
    fragMain << "}\n";

    return glu::makeVtxFragSources(vertDecl.str() + vertMain.str(), fragDecl.str() + fragMain.str());
}

bool UniformLocationCase::verifyLocations(const glu::ShaderProgram &program, const vector<UniformInfo> &uniformList)
{
    using tcu::TestLog;

    const glw::Functions &gl = m_renderCtx.getFunctions();
    const bool vertexOk      = program.getShaderInfo(glu::SHADERTYPE_VERTEX).compileOk;
    const bool fragmentOk    = program.getShaderInfo(glu::SHADERTYPE_FRAGMENT).compileOk;
    const bool linkOk        = program.getProgramInfo().linkOk;
    const uint32_t programID = program.getProgram();

    TestLog &log = m_testCtx.getLog();
    std::set<int> usedLocations;

    log << program;

    if (!vertexOk || !fragmentOk || !linkOk)
    {
        log << TestLog::Message << "ERROR: shader failed to compile/link" << TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader failed to compile/link");
        return false;
    }

    for (int uniformNdx = 0; uniformNdx < int(uniformList.size()); uniformNdx++)
    {
        const UniformInfo &uniformInfo = uniformList[uniformNdx];
        int subTypeIndex               = 0;

        for (glu::BasicTypeIterator subTypeIter = glu::BasicTypeIterator::begin(&uniformInfo.type);
             subTypeIter != glu::BasicTypeIterator::end(&uniformInfo.type); subTypeIter++, subTypeIndex++)
        {
            const string name   = getUniformName(uniformNdx, uniformInfo.type, subTypeIter.getPath());
            const int gotLoc    = gl.getUniformLocation(programID, name.c_str());
            const int expectLoc = uniformInfo.location >= 0 ? uniformInfo.location + subTypeIndex : -1;

            if (expectLoc >= 0)
            {
                if (uniformInfo.checkLocation == 0 && gotLoc == -1)
                    continue;

                if (gotLoc != expectLoc)
                {
                    log << TestLog::Message << "ERROR: found uniform " << name << " in location " << gotLoc
                        << " when it should have been in " << expectLoc << TestLog::EndMessage;
                    m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Incorrect uniform location");
                    return false;
                }

                if (usedLocations.find(expectLoc) != usedLocations.end())
                {
                    log << TestLog::Message << "ERROR: expected uniform " << name << " in location " << gotLoc
                        << " but it has already been used" << TestLog::EndMessage;
                    m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Overlapping uniform location");
                    return false;
                }

                usedLocations.insert(expectLoc);
            }
            else if (gotLoc >= 0)
            {
                if (usedLocations.count(gotLoc))
                {
                    log << TestLog::Message << "ERROR: found uniform " << name << " in location " << gotLoc
                        << " which has already been used" << TestLog::EndMessage;
                    m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Overlapping uniform location");
                    return false;
                }

                usedLocations.insert(gotLoc);
            }
        }
    }

    return true;
}

// Check that shader output is white (or very close to it)
bool UniformLocationCase::verifyResult(const tcu::ConstPixelBufferAccess &access)
{
    using tcu::Vec4;

    const Vec4 threshold(0.1f, 0.1f, 0.1f, 0.1f);
    const Vec4 reference(1.0f, 1.0f, 1.0f, 1.0f);

    for (int y = 0; y < access.getHeight(); y++)
    {
        for (int x = 0; x < access.getWidth(); x++)
        {
            const Vec4 diff = abs(access.getPixel(x, y) - reference);

            if (!boolAll(lessThanEqual(diff, threshold)))
                return false;
        }
    }

    return true;
}

// get a 4 channel 8 bits each texture format that is usable by the given sampler type
uint32_t getTextureFormat(glu::DataType samplerType)
{
    using namespace glu;

    switch (samplerType)
    {
    case TYPE_SAMPLER_1D:
    case TYPE_SAMPLER_2D:
    case TYPE_SAMPLER_CUBE:
    case TYPE_SAMPLER_2D_ARRAY:
    case TYPE_SAMPLER_3D:
        return GL_RGBA8;

    case TYPE_INT_SAMPLER_1D:
    case TYPE_INT_SAMPLER_2D:
    case TYPE_INT_SAMPLER_CUBE:
    case TYPE_INT_SAMPLER_2D_ARRAY:
    case TYPE_INT_SAMPLER_3D:
        return GL_RGBA8I;

    case TYPE_UINT_SAMPLER_1D:
    case TYPE_UINT_SAMPLER_2D:
    case TYPE_UINT_SAMPLER_CUBE:
    case TYPE_UINT_SAMPLER_2D_ARRAY:
    case TYPE_UINT_SAMPLER_3D:
        return GL_RGBA8UI;

    default:
        DE_FATAL("Unsupported (sampler) type");
        return 0;
    }
}

// create a texture suitable for sampling by the given sampler type and bind it
de::MovePtr<glu::Texture2D> UniformLocationCase::createTexture(glu::DataType samplerType, float redChannelValue,
                                                               int binding)
{
    using namespace glu;

    const glw::Functions &gl = m_renderCtx.getFunctions();

    const uint32_t format = getTextureFormat(samplerType);
    de::MovePtr<Texture2D> tex;

    tex = de::MovePtr<Texture2D>(new Texture2D(m_renderCtx, format, 16, 16));

    tex->getRefTexture().allocLevel(0);

    if (format == GL_RGBA8I || format == GL_RGBA8UI)
        tcu::clear(tex->getRefTexture().getLevel(0), tcu::IVec4(int(redChannelValue), 0, 0, 0));
    else
        tcu::clear(tex->getRefTexture().getLevel(0), tcu::Vec4(redChannelValue, 0.0f, 0.0f, 1.0f));

    gl.activeTexture(GL_TEXTURE0 + binding);
    tex->upload();

    gl.bindTexture(GL_TEXTURE_2D, tex->getGLTexture());
    gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

    GLU_EXPECT_NO_ERROR(gl.getError(), "UniformLocationCase: texture upload");

    return tex;
}

void UniformLocationCase::render(const glu::ShaderProgram &program, const vector<UniformInfo> &uniformList)
{
    using de::MovePtr;
    using glu::Texture2D;
    typedef vector<Texture2D *> TextureList;

    const glw::Functions &gl = m_renderCtx.getFunctions();
    const uint32_t programID = program.getProgram();
    const int32_t posLoc     = gl.getAttribLocation(programID, "a_position");

    // Vertex data.
    const float position[]   = {-1.0f, -1.0f, 0.1f, 1.0f, -1.0f, 1.0f, 0.1f, 1.0f,
                                1.0f,  -1.0f, 0.1f, 1.0f, 1.0f,  1.0f, 0.1f, 1.0f};
    const void *positionPtr  = &position[0];
    const uint16_t indices[] = {0, 1, 2, 2, 1, 3};
    const void *indicesPtr   = &indices[0];

    // some buffers to feed to the GPU, only the first element is relevant since the others are never verified
    float floatBuf[16]  = {0.0f};
    int32_t intBuf[4]   = {0};
    uint32_t uintBuf[4] = {0};
    uint32_t vao        = 0;
    uint32_t attribVbo  = 0;
    uint32_t elementVbo = 0;

    TextureList texList;

    bool isGL45 = glu::contextSupports(m_renderCtx.getType(), glu::ApiType::core(4, 5));
    if (isGL45)
    {
        gl.genVertexArrays(1, &vao);
        gl.bindVertexArray(vao);

        gl.genBuffers(1, &attribVbo);
        gl.genBuffers(1, &elementVbo);

        gl.bindBuffer(GL_ARRAY_BUFFER, attribVbo);
        gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)(DE_LENGTH_OF_ARRAY(position) * sizeof(float)), position,
                      GL_STATIC_DRAW);
        GLU_EXPECT_NO_ERROR(gl.getError(), "UniformLocationCase::render");

        gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, elementVbo);
        gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (glw::GLsizeiptr)(DE_LENGTH_OF_ARRAY(indices) * sizeof(uint16_t)),
                      indices, GL_STATIC_DRAW);
        GLU_EXPECT_NO_ERROR(gl.getError(), "UniformLocationCase::render");

        positionPtr = 0;
        indicesPtr  = 0;
    }

    TCU_CHECK(posLoc >= 0);
    gl.useProgram(programID);

    try
    {

        // Set uniforms
        for (unsigned int uniformNdx = 0; uniformNdx < uniformList.size(); uniformNdx++)
        {
            const UniformInfo &uniformInfo = uniformList[uniformNdx];
            int expectedLocation           = uniformInfo.location;

            for (glu::BasicTypeIterator subTypeIter = glu::BasicTypeIterator::begin(&uniformInfo.type);
                 subTypeIter != glu::BasicTypeIterator::end(&uniformInfo.type); subTypeIter++)
            {
                const glu::VarType type        = glu::getVarType(uniformInfo.type, subTypeIter.getPath());
                const string name              = getUniformName(uniformNdx, uniformInfo.type, subTypeIter.getPath());
                const int gotLoc               = gl.getUniformLocation(programID, name.c_str());
                const glu::DataType scalarType = glu::getDataTypeScalarType(type.getBasicType());
                const char *const typeName     = glu::getDataTypeName(scalarType);
                const float expectedValue      = getExpectedValue(scalarType, expectedLocation, typeName);

                if (glu::isDataTypeSampler(scalarType))
                {
                    const int binding = (int)texList.size();

                    texList.push_back(createTexture(scalarType, expectedValue, binding).release());
                    gl.uniform1i(gotLoc, binding);
                }
                else if (gotLoc >= 0)
                {
                    floatBuf[0] = expectedValue;
                    intBuf[0]   = int(expectedValue);
                    uintBuf[0]  = uint32_t(expectedValue);

                    m_testCtx.getLog() << tcu::TestLog::Message << "Set uniform " << name << " in location " << gotLoc
                                       << " to " << expectedValue << tcu::TestLog::EndMessage;

                    switch (type.getBasicType())
                    {
                    case glu::TYPE_FLOAT:
                        gl.uniform1fv(gotLoc, 1, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_VEC2:
                        gl.uniform2fv(gotLoc, 1, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_VEC3:
                        gl.uniform3fv(gotLoc, 1, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_VEC4:
                        gl.uniform4fv(gotLoc, 1, floatBuf);
                        break;

                    case glu::TYPE_INT:
                        gl.uniform1iv(gotLoc, 1, intBuf);
                        break;
                    case glu::TYPE_INT_VEC2:
                        gl.uniform2iv(gotLoc, 1, intBuf);
                        break;
                    case glu::TYPE_INT_VEC3:
                        gl.uniform3iv(gotLoc, 1, intBuf);
                        break;
                    case glu::TYPE_INT_VEC4:
                        gl.uniform4iv(gotLoc, 1, intBuf);
                        break;

                    case glu::TYPE_UINT:
                        gl.uniform1uiv(gotLoc, 1, uintBuf);
                        break;
                    case glu::TYPE_UINT_VEC2:
                        gl.uniform2uiv(gotLoc, 1, uintBuf);
                        break;
                    case glu::TYPE_UINT_VEC3:
                        gl.uniform3uiv(gotLoc, 1, uintBuf);
                        break;
                    case glu::TYPE_UINT_VEC4:
                        gl.uniform4uiv(gotLoc, 1, uintBuf);
                        break;

                    case glu::TYPE_BOOL:
                        gl.uniform1iv(gotLoc, 1, intBuf);
                        break;
                    case glu::TYPE_BOOL_VEC2:
                        gl.uniform2iv(gotLoc, 1, intBuf);
                        break;
                    case glu::TYPE_BOOL_VEC3:
                        gl.uniform3iv(gotLoc, 1, intBuf);
                        break;
                    case glu::TYPE_BOOL_VEC4:
                        gl.uniform4iv(gotLoc, 1, intBuf);
                        break;

                    case glu::TYPE_FLOAT_MAT2:
                        gl.uniformMatrix2fv(gotLoc, 1, false, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_MAT2X3:
                        gl.uniformMatrix2x3fv(gotLoc, 1, false, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_MAT2X4:
                        gl.uniformMatrix2x4fv(gotLoc, 1, false, floatBuf);
                        break;

                    case glu::TYPE_FLOAT_MAT3X2:
                        gl.uniformMatrix3x2fv(gotLoc, 1, false, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_MAT3:
                        gl.uniformMatrix3fv(gotLoc, 1, false, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_MAT3X4:
                        gl.uniformMatrix3x4fv(gotLoc, 1, false, floatBuf);
                        break;

                    case glu::TYPE_FLOAT_MAT4X2:
                        gl.uniformMatrix4x2fv(gotLoc, 1, false, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_MAT4X3:
                        gl.uniformMatrix4x3fv(gotLoc, 1, false, floatBuf);
                        break;
                    case glu::TYPE_FLOAT_MAT4:
                        gl.uniformMatrix4fv(gotLoc, 1, false, floatBuf);
                        break;
                    default:
                        DE_ASSERT(false);
                    }
                }

                expectedLocation += expectedLocation >= 0;
            }
        }

        gl.enableVertexAttribArray(posLoc);
        GLU_EXPECT_NO_ERROR(gl.getError(), "error in glEnableVertexAttribArray");
        gl.vertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, positionPtr);
        GLU_EXPECT_NO_ERROR(gl.getError(), "error in glVertexAttribPointer");

        gl.drawElements(GL_TRIANGLES, DE_LENGTH_OF_ARRAY(indices), GL_UNSIGNED_SHORT, indicesPtr);
        GLU_EXPECT_NO_ERROR(gl.getError(), "error in glDrawElements");

        gl.disableVertexAttribArray(posLoc);
        GLU_EXPECT_NO_ERROR(gl.getError(), "error in glDisableVertexAttribArray");

        if (isGL45)
        {
            gl.bindBuffer(GL_ARRAY_BUFFER, 0);
            gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);

            gl.deleteBuffers(1, &attribVbo);
            gl.deleteBuffers(1, &elementVbo);
            gl.deleteVertexArrays(1, &vao);
        }
    }
    catch (...)
    {
        for (int i = 0; i < int(texList.size()); i++)
            delete texList[i];

        throw;
    }

    for (int i = 0; i < int(texList.size()); i++)
        delete texList[i];
}

class MaxUniformLocationCase : public UniformLocationCase
{
public:
    MaxUniformLocationCase(tcu::TestContext &context, glu::RenderContext &renderContext, const char *name,
                           const char *desc, const vector<UniformInfo> &uniformInfo);
    virtual ~MaxUniformLocationCase(void)
    {
    }
    virtual IterateResult iterate(void);
};

MaxUniformLocationCase::MaxUniformLocationCase(tcu::TestContext &context, glu::RenderContext &renderContext,
                                               const char *name, const char *desc,
                                               const vector<UniformInfo> &uniformInfo)
    : UniformLocationCase(context, renderContext, name, desc, uniformInfo)
{
    DE_ASSERT(!uniformInfo.empty());
}

UniformLocationCase::IterateResult MaxUniformLocationCase::iterate(void)
{
    int maxLocation                 = 1024;
    vector<UniformInfo> uniformInfo = m_uniformInfo;

    m_renderCtx.getFunctions().getIntegerv(GL_MAX_UNIFORM_LOCATIONS, &maxLocation);

    uniformInfo[0].location = maxLocation - 1;

    return UniformLocationCase::run(uniformInfo);
}

} // namespace

UniformLocationTests::UniformLocationTests(Context &context, bool isGL45)
    : TestCaseGroup(context, "uniform_location", "Explicit uniform locations")
    , m_isGL45(isGL45)
{
}

UniformLocationTests::~UniformLocationTests(void)
{
    for (int i = 0; i < int(structTypes.size()); i++)
        delete structTypes[i];
}

glu::VarType createVarType(glu::DataType type)
{
    return glu::VarType(type, glu::isDataTypeBoolOrBVec(type) ? glu::PRECISION_LAST : glu::PRECISION_HIGHP);
}

void UniformLocationTests::init(void)
{
    using namespace glu;

    const UniformInfo::ShaderStage checkStages[] = {UniformInfo::SHADERSTAGE_VERTEX, UniformInfo::SHADERSTAGE_FRAGMENT};
    const char *stageNames[]                     = {"vertex", "fragment"};
    const int maxLocations                       = 1024;
    const int baseSeed                           = m_context.getTestContext().getCommandLine().getBaseSeed();

    const DataType primitiveTypes[] = {
        TYPE_FLOAT,        TYPE_FLOAT_VEC2,     TYPE_FLOAT_VEC3,      TYPE_FLOAT_VEC4,

        TYPE_INT,          TYPE_INT_VEC2,       TYPE_INT_VEC3,        TYPE_INT_VEC4,

        TYPE_UINT,         TYPE_UINT_VEC2,      TYPE_UINT_VEC3,       TYPE_UINT_VEC4,

        TYPE_BOOL,         TYPE_BOOL_VEC2,      TYPE_BOOL_VEC3,       TYPE_BOOL_VEC4,

        TYPE_FLOAT_MAT2,   TYPE_FLOAT_MAT2X3,   TYPE_FLOAT_MAT2X4,    TYPE_FLOAT_MAT3X2, TYPE_FLOAT_MAT3,
        TYPE_FLOAT_MAT3X4, TYPE_FLOAT_MAT4X2,   TYPE_FLOAT_MAT4X3,    TYPE_FLOAT_MAT4,

        TYPE_SAMPLER_2D,   TYPE_INT_SAMPLER_2D, TYPE_UINT_SAMPLER_2D,
    };

    const int maxPrimitiveTypeNdx = DE_LENGTH_OF_ARRAY(primitiveTypes) - 4;
    DE_ASSERT(primitiveTypes[maxPrimitiveTypeNdx] == TYPE_FLOAT_MAT4);

    // Primitive type cases with trivial linkage
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "basic", "Location specified with use, single shader stage");
        de::Random rng(baseSeed + 0x1001);
        addChild(group);

        for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
        {
            const DataType type = primitiveTypes[primitiveNdx];

            for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
            {
                const string name = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];

                vector<UniformInfo> config;

                UniformInfo uniform(createVarType(type), checkStages[stageNdx], checkStages[stageNdx],
                                    checkStages[stageNdx], rng.getInt(0, maxLocations - 1));

                config.push_back(uniform);
                group->addChild(new UniformLocationCase(m_testCtx, m_context.getRenderContext(), name.c_str(),
                                                        name.c_str(), config));
            }
        }
    }

    // Arrays
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "array", "Array location specified with use, single shader stage");
        de::Random rng(baseSeed + 0x2001);
        addChild(group);

        for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
        {
            const DataType type = primitiveTypes[primitiveNdx];

            for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
            {

                const string name = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];

                vector<UniformInfo> config;

                UniformInfo uniform(VarType(createVarType(type), 8), checkStages[stageNdx], checkStages[stageNdx],
                                    checkStages[stageNdx], rng.getInt(0, maxLocations - 1 - 8));

                config.push_back(uniform);
                group->addChild(new UniformLocationCase(m_testCtx, m_context.getRenderContext(), name.c_str(),
                                                        name.c_str(), config));
            }
        }
    }

    // Nested Arrays
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "nested_array", "Array location specified with use, single shader stage");
        de::Random rng(baseSeed + 0x3001);
        addChild(group);

        for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
        {
            const DataType type = primitiveTypes[primitiveNdx];

            for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
            {
                const string name = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];
                // stay comfortably within minimum max uniform component count (896 in fragment) and sampler count with all types
                const int arraySize = (getDataTypeScalarSize(type) > 4 || isDataTypeSampler(type)) ? 3 : 7;

                vector<UniformInfo> config;

                UniformInfo uniform(VarType(VarType(createVarType(type), arraySize), arraySize), checkStages[stageNdx],
                                    checkStages[stageNdx], checkStages[stageNdx],
                                    rng.getInt(0, maxLocations - 1 - arraySize * arraySize));

                config.push_back(uniform);
                group->addChild(new UniformLocationCase(m_testCtx, m_context.getRenderContext(), name.c_str(),
                                                        name.c_str(), config));
            }
        }
    }

    // Structs
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "struct", "Struct location, random contents & declaration location");
        de::Random rng(baseSeed + 0x4001);
        addChild(group);

        for (int caseNdx = 0; caseNdx < 16; caseNdx++)
        {
            typedef UniformInfo::ShaderStage Stage;

            const string name = "case_" + de::toString(caseNdx);

            const Stage layoutLoc  = Stage(rng.getUint32() & 0x3);
            const Stage declareLoc = Stage((rng.getUint32() & 0x3) | layoutLoc);
            const Stage verifyLoc  = Stage((rng.getUint32() & 0x3) & declareLoc);
            const int location     = layoutLoc ? rng.getInt(0, maxLocations - 1 - 5) : -1;

            StructType *structProto = new StructType("S");

            structTypes.push_back(structProto);

            structProto->addMember("a", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            structProto->addMember("b", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            structProto->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            structProto->addMember("d", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            structProto->addMember("e", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));

            {
                vector<UniformInfo> config;

                config.push_back(UniformInfo(VarType(structProto), declareLoc, layoutLoc, verifyLoc, location));
                group->addChild(new UniformLocationCase(m_testCtx, m_context.getRenderContext(), name.c_str(),
                                                        name.c_str(), config));
            }
        }
    }

    // Nested Structs
    {
        tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(
            m_testCtx, "nested_struct", "Struct location specified with use, single shader stage");
        de::Random rng(baseSeed + 0x5001);

        addChild(group);

        for (int caseNdx = 0; caseNdx < 16; caseNdx++)
        {
            typedef UniformInfo::ShaderStage Stage;

            const string name = "case_" + de::toString(caseNdx);
            const int baseLoc = rng.getInt(0, maxLocations - 1 - 60);

            // Structs need to be added in the order of their declaration
            const Stage layoutLocs[] = {
                Stage(rng.getUint32() & 0x3),
                Stage(rng.getUint32() & 0x3),
                Stage(rng.getUint32() & 0x3),
                Stage(rng.getUint32() & 0x3),
            };

            const uint32_t tempDecl[] = {
                (rng.getUint32() & 0x3) | layoutLocs[0],
                (rng.getUint32() & 0x3) | layoutLocs[1],
                (rng.getUint32() & 0x3) | layoutLocs[2],
                (rng.getUint32() & 0x3) | layoutLocs[3],
            };

            // Component structs need to be declared if anything using them is declared
            const Stage declareLocs[] = {
                Stage(tempDecl[0] | tempDecl[1] | tempDecl[2] | tempDecl[3]),
                Stage(tempDecl[1] | tempDecl[2] | tempDecl[3]),
                Stage(tempDecl[2] | tempDecl[3]),
                Stage(tempDecl[3]),
            };

            const Stage verifyLocs[] = {
                Stage(rng.getUint32() & 0x3 & declareLocs[0]),
                Stage(rng.getUint32() & 0x3 & declareLocs[1]),
                Stage(rng.getUint32() & 0x3 & declareLocs[2]),
                Stage(rng.getUint32() & 0x3 & declareLocs[3]),
            };

            StructType *testTypes[] = {
                new StructType("Type0"),
                new StructType("Type1"),
                new StructType("Type2"),
                new StructType("Type3"),
            };

            structTypes.push_back(testTypes[0]);
            structTypes.push_back(testTypes[1]);
            structTypes.push_back(testTypes[2]);
            structTypes.push_back(testTypes[3]);

            testTypes[0]->addMember("a", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[0]->addMember("b", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[0]->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[0]->addMember("d", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[0]->addMember("e", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));

            testTypes[1]->addMember("a", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[1]->addMember("b", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[1]->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[1]->addMember("d", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));
            testTypes[1]->addMember("e", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));

            testTypes[2]->addMember("a", VarType(testTypes[0]));
            testTypes[2]->addMember("b", VarType(testTypes[1]));
            testTypes[2]->addMember("c", createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]));

            testTypes[3]->addMember("a", VarType(testTypes[2]));

            {
                vector<UniformInfo> config;

                config.push_back(UniformInfo(VarType(testTypes[0]), declareLocs[0], layoutLocs[0], verifyLocs[0],
                                             layoutLocs[0] ? baseLoc : -1));

                config.push_back(UniformInfo(VarType(testTypes[1]), declareLocs[1], layoutLocs[1], verifyLocs[1],
                                             layoutLocs[1] ? baseLoc + 5 : -1));

                config.push_back(UniformInfo(VarType(testTypes[2]), declareLocs[2], layoutLocs[2], verifyLocs[2],
                                             layoutLocs[2] ? baseLoc + 16 : -1));

                config.push_back(UniformInfo(VarType(testTypes[3]), declareLocs[3], layoutLocs[3], verifyLocs[3],
                                             layoutLocs[3] ? baseLoc + 27 : -1));

                group->addChild(new UniformLocationCase(m_testCtx, m_context.getRenderContext(), name.c_str(),
                                                        name.c_str(), config));
            }
        }
    }

    // Min/Max location
    {
        tcu::TestCaseGroup *const group = new tcu::TestCaseGroup(m_testCtx, "min_max", "Maximum & minimum location");

        addChild(group);

        for (int primitiveNdx = 0; primitiveNdx < DE_LENGTH_OF_ARRAY(primitiveTypes); primitiveNdx++)
        {
            const DataType type = primitiveTypes[primitiveNdx];

            for (int stageNdx = 0; stageNdx < DE_LENGTH_OF_ARRAY(checkStages); stageNdx++)
            {
                const string name = string(getDataTypeName(type)) + "_" + stageNames[stageNdx];
                vector<UniformInfo> config;

                config.push_back(UniformInfo(createVarType(type), checkStages[stageNdx], checkStages[stageNdx],
                                             checkStages[stageNdx], 0));

                group->addChild(new UniformLocationCase(m_testCtx, m_context.getRenderContext(),
                                                        (name + "_min").c_str(), (name + "_min").c_str(), config));

                group->addChild(new MaxUniformLocationCase(m_testCtx, m_context.getRenderContext(),
                                                           (name + "_max").c_str(), (name + "_max").c_str(), config));
            }
        }
    }

    // Link
    {
        tcu::TestCaseGroup *const group =
            new tcu::TestCaseGroup(m_testCtx, "link", "Location specified independently from use");
        de::Random rng(baseSeed + 0x82e1);

        addChild(group);

        for (int caseNdx = 0; caseNdx < 10; caseNdx++)
        {
            const string name = "case_" + de::toString(caseNdx);
            vector<UniformInfo> config;

            vector<int> locations = shuffledRange(0, maxLocations, 0x1234 + caseNdx * 100);

            for (int count = 0; count < 32; count++)
            {
                typedef UniformInfo::ShaderStage Stage;

                const Stage layoutLoc  = Stage(rng.getUint32() & 0x3);
                const Stage declareLoc = Stage((rng.getUint32() & 0x3) | layoutLoc);
                const Stage verifyLoc  = Stage((rng.getUint32() & 0x3) & declareLoc);

                const UniformInfo uniform(createVarType(primitiveTypes[rng.getInt(0, maxPrimitiveTypeNdx)]), declareLoc,
                                          layoutLoc, verifyLoc, (layoutLoc != 0) ? locations.back() : -1);

                config.push_back(uniform);
                locations.pop_back();
            }
            group->addChild(
                new UniformLocationCase(m_testCtx, m_context.getRenderContext(), name.c_str(), name.c_str(), config));
        }
    }

    // Negative
    {
        de::MovePtr<tcu::TestCaseGroup> negativeGroup(new tcu::TestCaseGroup(m_testCtx, "negative", "Negative tests"));

        {
            de::MovePtr<tcu::TestCaseGroup> es31Group(
                new tcu::TestCaseGroup(m_testCtx, "es31", "GLSL ES 3.1 Negative tests"));
            gls::ShaderLibrary shaderLibrary(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo());
            const vector<TestNode *> negativeCases = shaderLibrary.loadShaderFile("shaders/es31/uniform_location.test");

            for (int ndx = 0; ndx < int(negativeCases.size()); ndx++)
                es31Group->addChild(negativeCases[ndx]);

            negativeGroup->addChild(es31Group.release());
        }

        // ES only
        if (!m_isGL45)
        {
            de::MovePtr<tcu::TestCaseGroup> es32Group(
                new tcu::TestCaseGroup(m_testCtx, "es32", "GLSL ES 3.2 Negative tests"));
            gls::ShaderLibrary shaderLibrary(m_testCtx, m_context.getRenderContext(), m_context.getContextInfo());
            const vector<TestNode *> negativeCases = shaderLibrary.loadShaderFile("shaders/es32/uniform_location.test");

            for (int ndx = 0; ndx < int(negativeCases.size()); ndx++)
                es32Group->addChild(negativeCases[ndx]);

            negativeGroup->addChild(es32Group.release());
        }

        addChild(negativeGroup.release());
    }
}

} // namespace Functional
} // namespace gles31
} // namespace deqp