gles3/functional/es3fShaderApiTests.cpp

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 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 Shader API tests.
 *//*--------------------------------------------------------------------*/

#include "es3fShaderApiTests.hpp"
#include "es3fApiCase.hpp"
#include "tcuTestLog.hpp"

#include "gluRenderContext.hpp"
#include "gluShaderProgram.hpp"
#include "gluShaderUtil.hpp"
#include "gluDrawUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluCallLogWrapper.hpp"

#include "glwFunctions.hpp"
#include "glwDefs.hpp"
#include "glwEnums.hpp"

#include "deString.h"

#include "deRandom.hpp"
#include "deStringUtil.hpp"

#include <string>
#include <sstream>
#include <vector>
#include <map>

using namespace glw; // GL types

namespace deqp
{
namespace gles3
{
namespace Functional
{

using tcu::TestLog;

namespace
{

enum ShaderSourceCaseFlags
{
    CASE_EXPLICIT_SOURCE_LENGTHS = 1,
    CASE_RANDOM_NULL_TERMINATED  = 2
};

struct ShaderSources
{
    std::vector<std::string> strings;
    std::vector<int> lengths;
};

// Simple shaders

const char *getSimpleShaderSource(const glu::ShaderType shaderType)
{
    const char *simpleVertexShaderSource = "#version 300 es\n"
                                           "void main (void)\n"
                                           "{\n"
                                           "    gl_Position = vec4(0.0);\n"
                                           "}\n";

    const char *simpleFragmentShaderSource = "#version 300 es\n"
                                             "layout(location = 0) out mediump vec4 o_fragColor;\n"
                                             "void main (void)\n"
                                             "{\n"
                                             "    o_fragColor = vec4(0.0);\n"
                                             "}\n";

    switch (shaderType)
    {
    case glu::SHADERTYPE_VERTEX:
        return simpleVertexShaderSource;
    case glu::SHADERTYPE_FRAGMENT:
        return simpleFragmentShaderSource;
    default:
        DE_ASSERT(false);
    }

    return 0;
}

void setShaderSources(glu::Shader &shader, const ShaderSources &sources)
{
    std::vector<const char *> cStrings(sources.strings.size(), 0);

    for (size_t ndx = 0; ndx < sources.strings.size(); ndx++)
        cStrings[ndx] = sources.strings[ndx].c_str();

    if (sources.lengths.size() > 0)
        shader.setSources((int)cStrings.size(), &cStrings[0], &sources.lengths[0]);
    else
        shader.setSources((int)cStrings.size(), &cStrings[0], 0);
}

void sliceSourceString(const std::string &in, ShaderSources &out, const int numSlices, const size_t paddingLength = 0)
{
    DE_ASSERT(numSlices > 0);

    const size_t sliceSize          = in.length() / numSlices;
    const size_t sliceSizeRemainder = in.length() - (sliceSize * numSlices);
    const std::string padding(paddingLength, 'E');

    for (int ndx = 0; ndx < numSlices; ndx++)
    {
        out.strings.push_back(in.substr(ndx * sliceSize, sliceSize) + padding);

        if (paddingLength > 0)
            out.lengths.push_back((int)sliceSize);
    }

    if (sliceSizeRemainder > 0)
    {
        const std::string lastString = in.substr(numSlices * sliceSize);
        const int lastStringLength   = (int)lastString.length();

        out.strings.push_back(lastString + padding);

        if (paddingLength > 0)
            out.lengths.push_back(lastStringLength);
    }
}

void queryShaderInfo(glu::RenderContext &renderCtx, uint32_t shader, glu::ShaderInfo &info)
{
    const glw::Functions &gl = renderCtx.getFunctions();

    info.compileOk     = false;
    info.compileTimeUs = 0;
    info.infoLog.clear();

    // Query source, status & log.
    {
        int compileStatus = 0;
        int sourceLen     = 0;
        int infoLogLen    = 0;
        int unusedLen;

        gl.getShaderiv(shader, GL_COMPILE_STATUS, &compileStatus);
        gl.getShaderiv(shader, GL_SHADER_SOURCE_LENGTH, &sourceLen);
        gl.getShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLen);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv()");

        info.compileOk = compileStatus != GL_FALSE;

        if (sourceLen > 0)
        {
            std::vector<char> source(sourceLen);
            gl.getShaderSource(shader, (int)source.size(), &unusedLen, &source[0]);
            info.source = std::string(&source[0], sourceLen);
        }

        if (infoLogLen > 0)
        {
            std::vector<char> infoLog(infoLogLen);
            gl.getShaderInfoLog(shader, (int)infoLog.size(), &unusedLen, &infoLog[0]);
            info.infoLog = std::string(&infoLog[0], infoLogLen);
        }
    }
}

// Draw test quad

void drawWithProgram(glu::RenderContext &renderCtx, uint32_t program)
{
    const glw::Functions &gl = renderCtx.getFunctions();

    const float position[]       = {-1.0f, -1.0f, 0.0f, 1.0f, -1.0f, +1.0f, 0.0f, 1.0f,
                                    +1.0f, -1.0f, 0.0f, 1.0f, +1.0f, +1.0f, 0.0f, 1.0f};
    const uint16_t quadIndices[] = {0, 1, 2, 2, 1, 3};

    gl.useProgram(program);

    {
        glu::VertexArrayBinding vertexArrays[] = {glu::va::Float("a_position", 4, 4, 0, &position[0])};
        glu::draw(renderCtx, program, DE_LENGTH_OF_ARRAY(vertexArrays), &vertexArrays[0],
                  glu::pr::Triangles(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0]));
    }

    GLU_EXPECT_NO_ERROR(gl.getError(), "Draw test quad");
}

// Shader source generator

class SourceGenerator
{
public:
    virtual ~SourceGenerator(void)
    {
    }

    virtual std::string next(const glu::ShaderType shaderType)    = 0;
    virtual bool finished(const glu::ShaderType shaderType) const = 0;
};

class ConstantShaderGenerator : public SourceGenerator
{
public:
    ConstantShaderGenerator(de::Random &rnd) : m_rnd(rnd)
    {
    }
    ~ConstantShaderGenerator(void)
    {
    }

    bool finished(const glu::ShaderType shaderType) const
    {
        DE_UNREF(shaderType);
        return false;
    }

    std::string next(const glu::ShaderType shaderType);

private:
    de::Random m_rnd;
};

std::string ConstantShaderGenerator::next(const glu::ShaderType shaderType)
{
    DE_ASSERT(shaderType == glu::SHADERTYPE_VERTEX || shaderType == glu::SHADERTYPE_FRAGMENT);

    const float value             = m_rnd.getFloat(0.0f, 1.0f);
    const std::string valueString = de::toString(value);
    const std::string outputName  = (shaderType == glu::SHADERTYPE_VERTEX) ? "gl_Position" : "o_fragColor";

    std::ostringstream out;

    out << "#version 300 es\n";

    if (shaderType == glu::SHADERTYPE_FRAGMENT)
        out << "layout(location = 0) out mediump vec4 o_fragColor;\n";

    out << "void main (void)\n";
    out << "{\n";
    out << "    " << outputName << " = vec4(" << valueString << ");\n";
    out << "}\n";

    return out.str();
}

// Shader allocation utility

class ShaderAllocator
{
public:
    ShaderAllocator(glu::RenderContext &context, SourceGenerator &generator);
    ~ShaderAllocator(void);

    bool hasShader(const glu::ShaderType shaderType);

    void setSource(const glu::ShaderType shaderType);

    glu::Shader &createShader(const glu::ShaderType shaderType);
    void deleteShader(const glu::ShaderType shaderType);

    glu::Shader &get(const glu::ShaderType shaderType)
    {
        DE_ASSERT(hasShader(shaderType));
        return *m_shaders[shaderType];
    }

private:
    const glu::RenderContext &m_context;
    SourceGenerator &m_srcGen;
    std::map<glu::ShaderType, glu::Shader *> m_shaders;
};

ShaderAllocator::ShaderAllocator(glu::RenderContext &context, SourceGenerator &generator)
    : m_context(context)
    , m_srcGen(generator)
{
}

ShaderAllocator::~ShaderAllocator(void)
{
    for (std::map<glu::ShaderType, glu::Shader *>::iterator shaderIter = m_shaders.begin();
         shaderIter != m_shaders.end(); shaderIter++)
        delete shaderIter->second;
    m_shaders.clear();
}

bool ShaderAllocator::hasShader(const glu::ShaderType shaderType)
{
    if (m_shaders.find(shaderType) != m_shaders.end())
        return true;
    else
        return false;
}

glu::Shader &ShaderAllocator::createShader(const glu::ShaderType shaderType)
{
    DE_ASSERT(!this->hasShader(shaderType));

    glu::Shader *const shader = new glu::Shader(m_context, shaderType);

    m_shaders[shaderType] = shader;
    this->setSource(shaderType);

    return *shader;
}

void ShaderAllocator::deleteShader(const glu::ShaderType shaderType)
{
    DE_ASSERT(this->hasShader(shaderType));

    delete m_shaders[shaderType];
    m_shaders.erase(shaderType);
}

void ShaderAllocator::setSource(const glu::ShaderType shaderType)
{
    DE_ASSERT(this->hasShader(shaderType));
    DE_ASSERT(!m_srcGen.finished(shaderType));

    const std::string source  = m_srcGen.next(shaderType);
    const char *const cSource = source.c_str();

    m_shaders[shaderType]->setSources(1, &cSource, 0);
}

// Logging utilities

void logShader(TestLog &log, glu::RenderContext &renderCtx, glu::Shader &shader)
{
    glu::ShaderInfo info;

    queryShaderInfo(renderCtx, shader.getShader(), info);

    log << TestLog::Shader(getLogShaderType(shader.getType()), info.source, info.compileOk, info.infoLog);
}

void logProgram(TestLog &log, glu::RenderContext &renderCtx, glu::Program &program, ShaderAllocator &shaders)
{
    log << TestLog::ShaderProgram(program.getLinkStatus(), program.getInfoLog());

    for (int shaderTypeInt = 0; shaderTypeInt < glu::SHADERTYPE_LAST; shaderTypeInt++)
    {
        const glu::ShaderType shaderType = (glu::ShaderType)shaderTypeInt;

        if (shaders.hasShader(shaderType))
            logShader(log, renderCtx, shaders.get(shaderType));
    }

    log << TestLog::EndShaderProgram;
}

void logVertexFragmentProgram(TestLog &log, glu::RenderContext &renderCtx, glu::Program &program,
                              glu::Shader &vertShader, glu::Shader &fragShader)
{
    DE_ASSERT(vertShader.getType() == glu::SHADERTYPE_VERTEX && fragShader.getType() == glu::SHADERTYPE_FRAGMENT);

    log << TestLog::ShaderProgram(program.getLinkStatus(), program.getInfoLog());

    logShader(log, renderCtx, vertShader);
    logShader(log, renderCtx, fragShader);

    log << TestLog::EndShaderProgram;
}

} // namespace

// Simple glCreateShader() case

class CreateShaderCase : public ApiCase
{
public:
    CreateShaderCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ApiCase(context, name, desc)
        , m_shaderType(shaderType)
    {
    }

    void test(void)
    {
        const GLuint shaderObject = glCreateShader(glu::getGLShaderType(m_shaderType));

        TCU_CHECK(shaderObject != 0);

        glDeleteShader(shaderObject);
    }

private:
    const glu::ShaderType m_shaderType;
};

// Simple glCompileShader() case

class CompileShaderCase : public ApiCase
{
public:
    CompileShaderCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ApiCase(context, name, desc)
        , m_shaderType(shaderType)
    {
    }

    bool checkCompileStatus(const GLuint shaderObject)
    {
        GLint compileStatus = -1;
        glGetShaderiv(shaderObject, GL_COMPILE_STATUS, &compileStatus);
        GLU_CHECK();

        return (compileStatus == GL_TRUE);
    }

    void test(void)
    {
        const char *shaderSource  = getSimpleShaderSource(m_shaderType);
        const GLuint shaderObject = glCreateShader(glu::getGLShaderType(m_shaderType));

        TCU_CHECK(shaderObject != 0);

        glShaderSource(shaderObject, 1, &shaderSource, 0);
        glCompileShader(shaderObject);

        TCU_CHECK(checkCompileStatus(shaderObject));

        glDeleteShader(shaderObject);
    }

private:
    const glu::ShaderType m_shaderType;
};

// Base class for simple program API tests

class SimpleProgramCase : public ApiCase
{
public:
    SimpleProgramCase(Context &context, const char *name, const char *desc)
        : ApiCase(context, name, desc)
        , m_vertShader(0)
        , m_fragShader(0)
        , m_program(0)
    {
    }

    virtual ~SimpleProgramCase(void)
    {
    }

    virtual void compileShaders(void)
    {
        const char *vertSource = getSimpleShaderSource(glu::SHADERTYPE_VERTEX);
        const char *fragSource = getSimpleShaderSource(glu::SHADERTYPE_FRAGMENT);

        const GLuint vertShader = glCreateShader(GL_VERTEX_SHADER);
        const GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER);

        TCU_CHECK(vertShader != 0);
        TCU_CHECK(fragShader != 0);

        glShaderSource(vertShader, 1, &vertSource, 0);
        glCompileShader(vertShader);

        glShaderSource(fragShader, 1, &fragSource, 0);
        glCompileShader(fragShader);

        GLU_CHECK();

        m_vertShader = vertShader;
        m_fragShader = fragShader;
    }

    void linkProgram(void)
    {
        const GLuint program = glCreateProgram();

        TCU_CHECK(program != 0);

        glAttachShader(program, m_vertShader);
        glAttachShader(program, m_fragShader);
        GLU_CHECK();

        glLinkProgram(program);

        m_program = program;
    }

    void cleanup(void)
    {
        glDeleteShader(m_vertShader);
        glDeleteShader(m_fragShader);
        glDeleteProgram(m_program);
    }

protected:
    GLuint m_vertShader;
    GLuint m_fragShader;
    GLuint m_program;
};

// glDeleteShader() case

class DeleteShaderCase : public SimpleProgramCase
{
public:
    DeleteShaderCase(Context &context, const char *name, const char *desc) : SimpleProgramCase(context, name, desc)
    {
    }

    bool checkDeleteStatus(GLuint shader)
    {
        GLint deleteStatus = -1;
        glGetShaderiv(shader, GL_DELETE_STATUS, &deleteStatus);
        GLU_CHECK();

        return (deleteStatus == GL_TRUE);
    }

    void deleteShaders(void)
    {
        glDeleteShader(m_vertShader);
        glDeleteShader(m_fragShader);
        GLU_CHECK();
    }

    void test(void)
    {
        compileShaders();
        linkProgram();
        GLU_CHECK();

        deleteShaders();

        TCU_CHECK(checkDeleteStatus(m_vertShader) && checkDeleteStatus(m_fragShader));

        glDeleteProgram(m_program);

        TCU_CHECK(!(glIsShader(m_vertShader) || glIsShader(m_fragShader)));
    }
};

// Simple glLinkProgram() case

class LinkVertexFragmentCase : public SimpleProgramCase
{
public:
    LinkVertexFragmentCase(Context &context, const char *name, const char *desc)
        : SimpleProgramCase(context, name, desc)
    {
    }

    bool checkLinkStatus(const GLuint programObject)
    {
        GLint linkStatus = -1;
        glGetProgramiv(programObject, GL_LINK_STATUS, &linkStatus);
        GLU_CHECK();

        return (linkStatus == GL_TRUE);
    }

    void test(void)
    {
        compileShaders();
        linkProgram();

        GLU_CHECK_MSG("Linking failed.");
        TCU_CHECK_MSG(checkLinkStatus(m_program), "Fail, expected LINK_STATUS to be TRUE.");

        cleanup();
    }
};

class ShaderSourceReplaceCase : public ApiCase
{
public:
    ShaderSourceReplaceCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ApiCase(context, name, desc)
        , m_shaderType(shaderType)
    {
    }

    std::string generateFirstSource(void)
    {
        return getSimpleShaderSource(m_shaderType);
    }

    std::string generateSecondSource(void)
    {
        std::ostringstream out;

        out << "#version 300 es\n";
        out << "precision mediump float;\n";

        if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
            out << "layout(location = 0) out mediump vec4 o_fragColor;\n";

        out << "void main()\n";
        out << "{\n";
        out << "    float variable = 1.0f;\n";

        if (m_shaderType == glu::SHADERTYPE_VERTEX)
            out << "    gl_Position = vec4(variable);\n";
        else if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
            out << "    o_fragColor = vec4(variable);\n";

        out << "}\n";

        return out.str();
    }

    GLint getSourceLength(glu::Shader &shader)
    {
        GLint sourceLength = 0;
        glGetShaderiv(shader.getShader(), GL_SHADER_SOURCE_LENGTH, &sourceLength);
        GLU_CHECK();

        return sourceLength;
    }

    std::string readSource(glu::Shader &shader)
    {
        const GLint sourceLength = getSourceLength(shader);
        std::vector<char> sourceBuffer(sourceLength + 1);

        glGetShaderSource(shader.getShader(), (GLsizei)sourceBuffer.size(), 0, &sourceBuffer[0]);

        return std::string(&sourceBuffer[0]);
    }

    void verifyShaderSourceReplaced(glu::Shader &shader, const std::string &firstSource,
                                    const std::string &secondSource)
    {
        TestLog &log             = m_testCtx.getLog();
        const std::string result = readSource(shader);

        if (result == firstSource)
        {
            log << TestLog::Message << "Fail, source was not replaced." << TestLog::EndMessage;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader source nor replaced");
        }
        else if (result != secondSource)
        {
            log << TestLog::Message << "Fail, invalid shader source." << TestLog::EndMessage;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid source");
        }
    }

    void test(void)
    {
        TestLog &log = m_testCtx.getLog();

        glu::Shader shader(m_context.getRenderContext(), m_shaderType);

        const std::string firstSourceStr  = generateFirstSource();
        const std::string secondSourceStr = generateSecondSource();

        const char *firstSource  = firstSourceStr.c_str();
        const char *secondSource = secondSourceStr.c_str();

        log << TestLog::Message << "Setting shader source." << TestLog::EndMessage;

        shader.setSources(1, &firstSource, 0);
        GLU_CHECK();

        log << TestLog::Message << "Replacing shader source." << TestLog::EndMessage;

        shader.setSources(1, &secondSource, 0);
        GLU_CHECK();

        verifyShaderSourceReplaced(shader, firstSourceStr, secondSourceStr);
    }

private:
    glu::ShaderType m_shaderType;
};

// glShaderSource() split source case

class ShaderSourceSplitCase : public ApiCase
{
public:
    ShaderSourceSplitCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType,
                          const int numSlices, const uint32_t flags = 0)
        : ApiCase(context, name, desc)
        , m_rnd(deStringHash(getName()) ^ 0x4fb2337d)
        , m_shaderType(shaderType)
        , m_numSlices(numSlices)
        , m_explicitLengths((flags & CASE_EXPLICIT_SOURCE_LENGTHS) != 0)
        , m_randomNullTerm((flags & CASE_RANDOM_NULL_TERMINATED) != 0)
    {
        DE_ASSERT(m_shaderType == glu::SHADERTYPE_VERTEX || m_shaderType == glu::SHADERTYPE_FRAGMENT);
    }

    virtual ~ShaderSourceSplitCase(void)
    {
    }

    std::string generateFullSource(void)
    {
        std::ostringstream out;

        out << "#version 300 es\n";
        out << "precision mediump float;\n";

        if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
            out << "layout(location = 0) out mediump vec4 o_fragColor;\n";

        out << "void main()\n";
        out << "{\n";
        out << "    float variable = 1.0f;\n";

        if (m_shaderType == glu::SHADERTYPE_VERTEX)
            out << "    gl_Position = vec4(variable);\n";
        else if (m_shaderType == glu::SHADERTYPE_FRAGMENT)
            out << "    o_fragColor = vec4(variable);\n";

        out << "}\n";

        return out.str();
    }

    void insertRandomNullTermStrings(ShaderSources &sources)
    {
        const int numInserts = de::max(m_numSlices >> 2, 1);
        std::vector<int> indices(sources.strings.size(), 0);

        DE_ASSERT(sources.lengths.size() > 0);
        DE_ASSERT(sources.lengths.size() == sources.strings.size());

        for (int i = 0; i < (int)sources.strings.size(); i++)
            indices[i] = i;

        m_rnd.shuffle(indices.begin(), indices.end());

        for (int i = 0; i < numInserts; i++)
        {
            const int ndx                    = indices[i];
            const int unpaddedLength         = sources.lengths[ndx];
            const std::string unpaddedString = sources.strings[ndx].substr(0, unpaddedLength);

            sources.strings[ndx] = unpaddedString;
            sources.lengths[ndx] = m_rnd.getInt(-10, -1);
        }
    }

    void generateSources(ShaderSources &sources)
    {
        const size_t paddingLength = (m_explicitLengths ? 10 : 0);
        std::string str            = generateFullSource();

        sliceSourceString(str, sources, m_numSlices, paddingLength);

        if (m_randomNullTerm)
            insertRandomNullTermStrings(sources);
    }

    void buildProgram(glu::Shader &shader)
    {
        TestLog &log                  = m_testCtx.getLog();
        glu::RenderContext &renderCtx = m_context.getRenderContext();

        const glu::ShaderType supportShaderType =
            (m_shaderType == glu::SHADERTYPE_FRAGMENT ? glu::SHADERTYPE_VERTEX : glu::SHADERTYPE_FRAGMENT);
        const char *supportShaderSource = getSimpleShaderSource(supportShaderType);
        glu::Shader supportShader(renderCtx, supportShaderType);

        glu::Program program(renderCtx);

        supportShader.setSources(1, &supportShaderSource, 0);
        supportShader.compile();

        program.attachShader(shader.getShader());
        program.attachShader(supportShader.getShader());

        program.link();

        if (m_shaderType == glu::SHADERTYPE_VERTEX)
            logVertexFragmentProgram(log, renderCtx, program, shader, supportShader);
        else
            logVertexFragmentProgram(log, renderCtx, program, supportShader, shader);
    }

    void test(void)
    {
        TestLog &log                  = m_testCtx.getLog();
        glu::RenderContext &renderCtx = m_context.getRenderContext();

        ShaderSources sources;
        glu::Shader shader(renderCtx, m_shaderType);

        generateSources(sources);
        setShaderSources(shader, sources);
        shader.compile();

        buildProgram(shader);

        if (!shader.getCompileStatus())
        {
            log << TestLog::Message << "Compilation failed." << TestLog::EndMessage;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Compile failed");
        }
    }

private:
    de::Random m_rnd;

    const glu::ShaderType m_shaderType;
    const int m_numSlices;

    const bool m_explicitLengths;
    const bool m_randomNullTerm;
};

// Base class for program state persistence cases

class ProgramStateCase : public ApiCase
{
public:
    ProgramStateCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType);
    virtual ~ProgramStateCase(void)
    {
    }

    void buildProgram(glu::Program &program, ShaderAllocator &shaders);
    void verify(glu::Program &program, const glu::ProgramInfo &reference);

    void test(void);

    virtual void executeForProgram(glu::Program &program, ShaderAllocator &shaders) = 0;

protected:
    de::Random m_rnd;
    const glu::ShaderType m_shaderType;
};

ProgramStateCase::ProgramStateCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
    : ApiCase(context, name, desc)
    , m_rnd(deStringHash(name) ^ 0x713de0ca)
    , m_shaderType(shaderType)
{
    DE_ASSERT(m_shaderType == glu::SHADERTYPE_VERTEX || m_shaderType == glu::SHADERTYPE_FRAGMENT);
}

void ProgramStateCase::buildProgram(glu::Program &program, ShaderAllocator &shaders)
{
    TestLog &log = m_testCtx.getLog();

    glu::Shader &vertShader = shaders.createShader(glu::SHADERTYPE_VERTEX);
    glu::Shader &fragShader = shaders.createShader(glu::SHADERTYPE_FRAGMENT);

    vertShader.compile();
    fragShader.compile();

    program.attachShader(vertShader.getShader());
    program.attachShader(fragShader.getShader());
    program.link();

    logProgram(log, m_context.getRenderContext(), program, shaders);
}

void ProgramStateCase::verify(glu::Program &program, const glu::ProgramInfo &reference)
{
    TestLog &log                        = m_testCtx.getLog();
    const glu::ProgramInfo &programInfo = program.getInfo();

    if (!programInfo.linkOk)
    {
        log << TestLog::Message
            << "Fail, link status may only change as a result of linking or loading a program binary."
            << TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Link status changed");
    }

    if (programInfo.linkTimeUs != reference.linkTimeUs)
    {
        log << TestLog::Message << "Fail, reported link time changed." << TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Link time changed");
    }

    if (programInfo.infoLog != reference.infoLog)
    {
        log << TestLog::Message << "Fail, program infolog changed." << TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Infolog changed");
    }
}

void ProgramStateCase::test(void)
{
    TestLog &log                  = m_testCtx.getLog();
    glu::RenderContext &renderCtx = m_context.getRenderContext();

    ConstantShaderGenerator sourceGen(m_rnd);

    ShaderAllocator shaders(renderCtx, sourceGen);
    glu::Program program(renderCtx);

    buildProgram(program, shaders);

    if (program.getLinkStatus())
    {
        glu::ProgramInfo programInfo = program.getInfo();

        executeForProgram(program, shaders);

        verify(program, programInfo);

        logProgram(log, renderCtx, program, shaders);
    }
    else
    {
        log << TestLog::Message << "Fail, couldn't link program." << TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Linking failed");
    }
}

// Program state case utilities

namespace
{

template <class T>
void addProgramStateCase(TestCaseGroup *group, Context &context, const std::string &name, const std::string &desc)
{
    for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
    {
        const glu::ShaderType shaderType = (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;
        const std::string shaderTypeName = getShaderTypeName(shaderType);

        const std::string caseName = name + "_" + shaderTypeName;
        const std::string caseDesc = "Build program, " + desc + ", for " + shaderTypeName + " shader.";

        group->addChild(new T(context, caseName.c_str(), caseDesc.c_str(), shaderType));
    }
}

} // namespace

// Specialized program state cases

class ProgramStateDetachShaderCase : public ProgramStateCase
{
public:
    ProgramStateDetachShaderCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ProgramStateCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramStateDetachShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Detaching " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
    }
};

class ProgramStateReattachShaderCase : public ProgramStateCase
{
public:
    ProgramStateReattachShaderCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ProgramStateCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramStateReattachShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Reattaching " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
        program.attachShader(caseShader.getShader());
    }
};

class ProgramStateDeleteShaderCase : public ProgramStateCase
{
public:
    ProgramStateDeleteShaderCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ProgramStateCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramStateDeleteShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Deleting " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
        shaders.deleteShader(m_shaderType);
    }
};

class ProgramStateReplaceShaderCase : public ProgramStateCase
{
public:
    ProgramStateReplaceShaderCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ProgramStateCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramStateReplaceShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Deleting and replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
        shaders.deleteShader(m_shaderType);
        program.attachShader(shaders.createShader(m_shaderType).getShader());
    }
};

class ProgramStateRecompileShaderCase : public ProgramStateCase
{
public:
    ProgramStateRecompileShaderCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ProgramStateCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramStateRecompileShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Recompiling " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        caseShader.compile();
        DE_UNREF(program);
    }
};

class ProgramStateReplaceSourceCase : public ProgramStateCase
{
public:
    ProgramStateReplaceSourceCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType)
        : ProgramStateCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramStateReplaceSourceCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message
            << "Replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader source and recompiling"
            << TestLog::EndMessage;
        shaders.setSource(m_shaderType);
        caseShader.compile();
        DE_UNREF(program);
    }
};

// Program binary utilities

namespace
{

struct ProgramBinary
{
    GLenum format;
    std::vector<uint8_t> data;
};

bool programBinariesEqual(const ProgramBinary &first, const ProgramBinary &second)
{
    if ((first.format != second.format) || (first.data.size() != second.data.size()))
        return false;

    return std::equal(first.data.begin(), first.data.end(), second.data.begin());
}

} // namespace

// Base class for program binary cases

class ProgramBinaryCase : public TestCase, protected glu::CallLogWrapper
{
public:
    ProgramBinaryCase(Context &context, const char *name, const char *desc);
    virtual ~ProgramBinaryCase(void);

    void getBinaryFormats(std::vector<GLenum> &out);
    bool isFormatSupported(const glw::GLenum format) const;

    void getProgramBinary(ProgramBinary &out, GLuint program);
    void loadProgramBinary(ProgramBinary &binary, GLuint program);

    void verifyProgramBinary(ProgramBinary &binary);

    void init(void);
    IterateResult iterate(void);

    virtual void test(void) = 0;

protected:
    std::vector<GLenum> m_formats;
};

ProgramBinaryCase::ProgramBinaryCase(Context &context, const char *name, const char *desc)
    : TestCase(context, name, desc)
    , CallLogWrapper(context.getRenderContext().getFunctions(), context.getTestContext().getLog())
{
}

ProgramBinaryCase::~ProgramBinaryCase(void)
{
}

void ProgramBinaryCase::getBinaryFormats(std::vector<GLenum> &out)
{
    GLint numFormats = -1;
    glGetIntegerv(GL_NUM_PROGRAM_BINARY_FORMATS, &numFormats);

    out.clear();

    if (numFormats > 0)
    {
        out.resize(numFormats, 0);

        glGetIntegerv(GL_PROGRAM_BINARY_FORMATS, (GLint *)&out[0]);
    }
}

bool ProgramBinaryCase::isFormatSupported(const glw::GLenum format) const
{
    return (std::find(m_formats.begin(), m_formats.end(), format) != m_formats.end());
}

void ProgramBinaryCase::getProgramBinary(ProgramBinary &out, GLuint program)
{
    GLint binaryLength = -1;
    glGetProgramiv(program, GL_PROGRAM_BINARY_LENGTH, &binaryLength);

    if (binaryLength > 0)
    {
        GLsizei actualLength;
        GLenum format;

        out.data.clear();
        out.data.resize(binaryLength, 0);

        GLU_CHECK_CALL(glGetProgramBinary(program, (GLsizei)out.data.size(), &actualLength, &format, &(out.data[0])));

        TCU_CHECK(actualLength == binaryLength);

        out.format = format;
    }
}

void ProgramBinaryCase::loadProgramBinary(ProgramBinary &binary, GLuint program)
{
    glProgramBinary(program, binary.format, &binary.data[0], (GLsizei)binary.data.size());
    GLU_CHECK_MSG("Failed to load program binary.");
}

void ProgramBinaryCase::verifyProgramBinary(ProgramBinary &binary)
{
    TestLog &log = m_testCtx.getLog();

    if (!isFormatSupported(binary.format))
    {
        log << TestLog::Message << "Program binary format " << binary.format
            << " is not among the supported formats reported by the platform." << TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid format");
    }
}

void ProgramBinaryCase::init(void)
{
    getBinaryFormats(m_formats);
}

tcu::TestNode::IterateResult ProgramBinaryCase::iterate(void)
{
    TestLog &log = m_testCtx.getLog();

    if (m_formats.empty())
    {
        log << TestLog::Message << "No program binary formats are supported." << TestLog::EndMessage;

        m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not supported");
    }
    else
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

        enableLogging(true);
        test();
    }

    return STOP;
}

// Simple program binary case

class ProgramBinarySimpleCase : public ProgramBinaryCase
{
public:
    ProgramBinarySimpleCase(Context &context, const char *name, const char *desc)
        : ProgramBinaryCase(context, name, desc)
    {
    }

    virtual ~ProgramBinarySimpleCase(void)
    {
    }

    void test(void)
    {
        const std::string vertSrc = getSimpleShaderSource(glu::SHADERTYPE_VERTEX);
        const std::string fragSrc = getSimpleShaderSource(glu::SHADERTYPE_FRAGMENT);

        const glu::ProgramSources sources = glu::makeVtxFragSources(vertSrc, fragSrc);

        glu::ShaderProgram program(m_context.getRenderContext(), sources);

        if (program.isOk())
        {
            ProgramBinary binary;

            getProgramBinary(binary, program.getProgram());
            verifyProgramBinary(binary);
        }
    }
};

// Program binary uniform reset case

class ProgramBinaryUniformResetCase : public ProgramBinaryCase
{
public:
    ProgramBinaryUniformResetCase(Context &context, const char *name, const char *desc)
        : ProgramBinaryCase(context, name, desc)
        , m_rnd(deStringHash(name) ^ 0xf2b48c6a)
    {
    }

    virtual ~ProgramBinaryUniformResetCase(void)
    {
    }

    std::string getShaderSource(const glu::ShaderType shaderType) const
    {
        const char *vertSrc = "#version 300 es\n"
                              "uniform bool u_boolVar;\n"
                              "uniform highp int u_intVar;\n"
                              "uniform highp float u_floatVar;\n\n"
                              "in highp vec4 a_position;\n\n"
                              "void main (void)\n"
                              "{\n"
                              "    gl_Position = a_position;\n"
                              "}\n";
        const char *fragSrc = "#version 300 es\n"
                              "uniform bool u_boolVar;\n"
                              "uniform highp int u_intVar;\n"
                              "uniform highp float u_floatVar;\n\n"
                              "layout(location = 0) out mediump vec4 o_fragColor;\n\n"
                              "void main (void)\n"
                              "{\n"
                              "    mediump float refAll = float(u_boolVar) + float(u_intVar) + u_floatVar;\n"
                              "    o_fragColor = vec4(refAll);\n"
                              "}\n";

        DE_ASSERT(shaderType == glu::SHADERTYPE_VERTEX || shaderType == glu::SHADERTYPE_FRAGMENT);

        return (shaderType == glu::SHADERTYPE_VERTEX) ? vertSrc : fragSrc;
    }

    void setUniformsRandom(glu::ShaderProgram &program)
    {
        TestLog &log          = m_testCtx.getLog();
        const uint32_t glProg = program.getProgram();

        log << TestLog::Message << "Setting uniforms to random non-zero values." << TestLog::EndMessage;

        glUseProgram(glProg);

        {
            const GLint boolLoc  = glGetUniformLocation(glProg, "u_boolVar");
            const GLint intLoc   = glGetUniformLocation(glProg, "u_intVar");
            const GLint floatLoc = glGetUniformLocation(glProg, "u_floatVar");

            const int32_t intVal = m_rnd.getInt(1, 1000);
            const float floatVal = m_rnd.getFloat(1.0, 1000.0);

            glUniform1i(boolLoc, GL_TRUE);
            glUniform1f(floatLoc, floatVal);
            glUniform1i(intLoc, intVal);
        }
    }

    void verifyUniformInt(glu::ShaderProgram &program, const std::string &name)
    {
        const GLint intLoc = glGetUniformLocation(program.getProgram(), name.c_str());
        GLint intVar       = -1;

        glGetUniformiv(program.getProgram(), intLoc, &intVar);

        if (intVar != 0)
        {
            m_testCtx.getLog() << TestLog::Message << "Fail, expected zero value for " << name
                               << ", received: " << intVar << TestLog::EndMessage;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Uniform value not reset");
        }
    }

    void verifyUniformFloat(glu::ShaderProgram &program, const std::string &name)
    {
        const GLint floatLoc = glGetUniformLocation(program.getProgram(), name.c_str());
        GLfloat floatVar     = -1;

        glGetUniformfv(program.getProgram(), floatLoc, &floatVar);

        if (floatVar != 0.0f)
        {
            m_testCtx.getLog() << TestLog::Message << "Fail, expected zero value for " << name
                               << ", received: " << de::toString(floatVar) << TestLog::EndMessage;
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Uniform value not reset");
        }
    }

    void verifyUniformsReset(glu::ShaderProgram &program)
    {
        m_testCtx.getLog() << TestLog::Message << "Verifying uniform reset to 0/false." << TestLog::EndMessage;

        verifyUniformInt(program, "u_boolVar");
        verifyUniformInt(program, "u_intVar");
        verifyUniformFloat(program, "u_floatVar");
    }

    void test(void)
    {
        TestLog &log = m_testCtx.getLog();

        const std::string vertSrc = getShaderSource(glu::SHADERTYPE_VERTEX);
        const std::string fragSrc = getShaderSource(glu::SHADERTYPE_FRAGMENT);

        const glu::ProgramSources sources = glu::makeVtxFragSources(vertSrc, fragSrc);

        glu::ShaderProgram program(m_context.getRenderContext(), sources);

        log << program;

        TCU_CHECK_MSG(program.isOk(), "Couldn't build program");

        {
            ProgramBinary binary;

            getProgramBinary(binary, program.getProgram());
            verifyProgramBinary(binary);

            setUniformsRandom(program);

            log << TestLog::Message << "Rendering test image and reloading binary" << TestLog::EndMessage;

            drawWithProgram(m_context.getRenderContext(), program.getProgram());
            loadProgramBinary(binary, program.getProgram());

            verifyUniformsReset(program);
        }
    }

private:
    de::Random m_rnd;
};

// Base class for program state persistence cases

class ProgramBinaryPersistenceCase : public ProgramBinaryCase
{
public:
    ProgramBinaryPersistenceCase(Context &context, const char *name, const char *desc, glu::ShaderType shaderType);
    virtual ~ProgramBinaryPersistenceCase(void)
    {
    }

    void buildProgram(glu::Program &program, ShaderAllocator &shaders);

    void test(void);

    virtual void executeForProgram(glu::Program &program, ShaderAllocator &shaders) = 0;
    virtual void verify(glu::Program &program, const ProgramBinary &binary);

protected:
    de::Random m_rnd;
    const glu::ShaderType m_shaderType;
};

ProgramBinaryPersistenceCase::ProgramBinaryPersistenceCase(Context &context, const char *name, const char *desc,
                                                           glu::ShaderType shaderType)
    : ProgramBinaryCase(context, name, desc)
    , m_rnd(deStringHash(name) ^ 0x713de0ca)
    , m_shaderType(shaderType)
{
    DE_ASSERT(m_shaderType == glu::SHADERTYPE_VERTEX || m_shaderType == glu::SHADERTYPE_FRAGMENT);
}

void ProgramBinaryPersistenceCase::buildProgram(glu::Program &program, ShaderAllocator &shaders)
{
    TestLog &log = m_testCtx.getLog();

    glu::Shader &vertShader = shaders.createShader(glu::SHADERTYPE_VERTEX);
    glu::Shader &fragShader = shaders.createShader(glu::SHADERTYPE_FRAGMENT);

    vertShader.compile();
    fragShader.compile();

    program.attachShader(vertShader.getShader());
    program.attachShader(fragShader.getShader());
    program.link();

    logProgram(log, m_context.getRenderContext(), program, shaders);
}

void ProgramBinaryPersistenceCase::verify(glu::Program &program, const ProgramBinary &binary)
{
    TestLog &log = m_testCtx.getLog();
    ProgramBinary currentBinary;

    getProgramBinary(currentBinary, program.getProgram());

    if (!programBinariesEqual(binary, currentBinary))
    {
        log << TestLog::Message << "Fail, program binary may only change as a result of linking or loading."
            << TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Program binary changed");
    }
}

void ProgramBinaryPersistenceCase::test(void)
{
    TestLog &log                  = m_testCtx.getLog();
    glu::RenderContext &renderCtx = m_context.getRenderContext();

    ConstantShaderGenerator sourceGen(m_rnd);

    ShaderAllocator shaders(renderCtx, sourceGen);
    glu::Program program(renderCtx);

    buildProgram(program, shaders);

    if (program.getLinkStatus())
    {
        ProgramBinary binary;
        getProgramBinary(binary, program.getProgram());

        executeForProgram(program, shaders);

        verify(program, binary);

        logProgram(log, renderCtx, program, shaders);
    }
    else
    {
        log << TestLog::Message << "Fail, couldn't link program." << TestLog::EndMessage;
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Linking failed");
    }
}

// Program state case utilities

namespace
{

template <class T>
void addProgramBinaryPersistenceCase(TestCaseGroup *group, Context &context, const std::string &name,
                                     const std::string &desc)
{
    for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
    {
        const glu::ShaderType shaderType = (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;
        const std::string shaderTypeName = getShaderTypeName(shaderType);

        const std::string caseName = name + "_" + shaderTypeName;
        const std::string caseDesc = "Build program, " + desc + ", for " + shaderTypeName + " shader.";

        group->addChild(new T(context, caseName.c_str(), caseDesc.c_str(), shaderType));
    }
}

} // namespace

// Specialized program state cases

class ProgramBinaryPersistenceDetachShaderCase : public ProgramBinaryPersistenceCase
{
public:
    ProgramBinaryPersistenceDetachShaderCase(Context &context, const char *name, const char *desc,
                                             glu::ShaderType shaderType)
        : ProgramBinaryPersistenceCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramBinaryPersistenceDetachShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Detaching " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
    }
};

class ProgramBinaryPersistenceReattachShaderCase : public ProgramBinaryPersistenceCase
{
public:
    ProgramBinaryPersistenceReattachShaderCase(Context &context, const char *name, const char *desc,
                                               glu::ShaderType shaderType)
        : ProgramBinaryPersistenceCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramBinaryPersistenceReattachShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Reattaching " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
        program.attachShader(caseShader.getShader());
    }
};

class ProgramBinaryPersistenceDeleteShaderCase : public ProgramBinaryPersistenceCase
{
public:
    ProgramBinaryPersistenceDeleteShaderCase(Context &context, const char *name, const char *desc,
                                             glu::ShaderType shaderType)
        : ProgramBinaryPersistenceCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramBinaryPersistenceDeleteShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Deleting " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
        shaders.deleteShader(m_shaderType);
    }
};

class ProgramBinaryPersistenceReplaceShaderCase : public ProgramBinaryPersistenceCase
{
public:
    ProgramBinaryPersistenceReplaceShaderCase(Context &context, const char *name, const char *desc,
                                              glu::ShaderType shaderType)
        : ProgramBinaryPersistenceCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramBinaryPersistenceReplaceShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Deleting and replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        program.detachShader(caseShader.getShader());
        shaders.deleteShader(m_shaderType);
        program.attachShader(shaders.createShader(m_shaderType).getShader());
    }
};

class ProgramBinaryPersistenceRecompileShaderCase : public ProgramBinaryPersistenceCase
{
public:
    ProgramBinaryPersistenceRecompileShaderCase(Context &context, const char *name, const char *desc,
                                                glu::ShaderType shaderType)
        : ProgramBinaryPersistenceCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramBinaryPersistenceRecompileShaderCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message << "Recompiling " + std::string(getShaderTypeName(m_shaderType)) + " shader"
            << TestLog::EndMessage;
        caseShader.compile();
        DE_UNREF(program);
    }
};

class ProgramBinaryPersistenceReplaceSourceCase : public ProgramBinaryPersistenceCase
{
public:
    ProgramBinaryPersistenceReplaceSourceCase(Context &context, const char *name, const char *desc,
                                              glu::ShaderType shaderType)
        : ProgramBinaryPersistenceCase(context, name, desc, shaderType)
    {
    }

    virtual ~ProgramBinaryPersistenceReplaceSourceCase(void)
    {
    }

    void executeForProgram(glu::Program &program, ShaderAllocator &shaders)
    {
        TestLog &log            = m_testCtx.getLog();
        glu::Shader &caseShader = shaders.get(m_shaderType);

        log << TestLog::Message
            << "Replacing " + std::string(getShaderTypeName(m_shaderType)) + " shader source and recompiling"
            << TestLog::EndMessage;
        shaders.setSource(m_shaderType);
        caseShader.compile();
        DE_UNREF(program);
    }
};

// Test group

ShaderApiTests::ShaderApiTests(Context &context) : TestCaseGroup(context, "shader_api", "Shader API Cases")
{
}

ShaderApiTests::~ShaderApiTests(void)
{
}

void ShaderApiTests::init(void)
{
    // create and delete shaders
    {
        TestCaseGroup *createDeleteGroup = new TestCaseGroup(m_context, "create_delete", "glCreateShader() tests");
        addChild(createDeleteGroup);

        createDeleteGroup->addChild(new CreateShaderCase(m_context, "create_vertex_shader",
                                                         "Create vertex shader object", glu::SHADERTYPE_VERTEX));
        createDeleteGroup->addChild(new CreateShaderCase(m_context, "create_fragment_shader",
                                                         "Create fragment shader object", glu::SHADERTYPE_FRAGMENT));

        createDeleteGroup->addChild(
            new DeleteShaderCase(m_context, "delete_vertex_fragment", "Delete vertex shader and fragment shader"));
    }

    // compile and link
    {
        TestCaseGroup *compileLinkGroup = new TestCaseGroup(m_context, "compile_link", "Compile and link tests");
        addChild(compileLinkGroup);

        compileLinkGroup->addChild(
            new CompileShaderCase(m_context, "compile_vertex_shader", "Compile vertex shader", glu::SHADERTYPE_VERTEX));
        compileLinkGroup->addChild(new CompileShaderCase(m_context, "compile_fragment_shader",
                                                         "Compile fragment shader", glu::SHADERTYPE_FRAGMENT));

        compileLinkGroup->addChild(
            new LinkVertexFragmentCase(m_context, "link_vertex_fragment", "Link vertex and fragment shaders"));
    }

    // shader source
    {
        TestCaseGroup *shaderSourceGroup = new TestCaseGroup(m_context, "shader_source", "glShaderSource() tests");
        addChild(shaderSourceGroup);

        for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
        {
            const glu::ShaderType shaderType = (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;
            const std::string shaderTypeName = getShaderTypeName(shaderType);

            const std::string caseName = std::string("replace_source_") + shaderTypeName;
            const std::string caseDesc = std::string("Replace source code of ") + shaderTypeName + " shader.";

            shaderSourceGroup->addChild(
                new ShaderSourceReplaceCase(m_context, caseName.c_str(), caseDesc.c_str(), shaderType));
        }

        for (int stringLengthsInt = 0; stringLengthsInt < 3; stringLengthsInt++)
            for (int caseNdx = 1; caseNdx <= 3; caseNdx++)
                for (int shaderTypeInt = 0; shaderTypeInt < 2; shaderTypeInt++)
                {
                    const int numSlices = 1 << caseNdx;
                    const glu::ShaderType shaderType =
                        (shaderTypeInt == 1) ? glu::SHADERTYPE_FRAGMENT : glu::SHADERTYPE_VERTEX;

                    const bool explicitLengths = (stringLengthsInt != 0);
                    const bool randomNullTerm  = (stringLengthsInt == 2);

                    const uint32_t flags = (explicitLengths ? CASE_EXPLICIT_SOURCE_LENGTHS : 0) |
                                           (randomNullTerm ? CASE_RANDOM_NULL_TERMINATED : 0);

                    const std::string caseName =
                        "split_source_" + de::toString(numSlices) +
                        (randomNullTerm ? "_random_negative_length" :
                                          (explicitLengths ? "_specify_lengths" : "_null_terminated")) +
                        ((shaderType == glu::SHADERTYPE_FRAGMENT) ? "_fragment" : "_vertex");

                    const std::string caseDesc =
                        std::string((shaderType == glu::SHADERTYPE_FRAGMENT) ? "Fragment" : "Vertex") +
                        " shader source split into " + de::toString(numSlices) + " pieces" +
                        (explicitLengths ? ", using explicitly specified string lengths" : "") +
                        (randomNullTerm ? " with random negative length values" : "");

                    shaderSourceGroup->addChild(new ShaderSourceSplitCase(m_context, caseName.c_str(), caseDesc.c_str(),
                                                                          shaderType, numSlices, flags));
                }
    }

    // link status and infolog
    {
        TestCaseGroup *linkStatusGroup =
            new TestCaseGroup(m_context, "program_state", "Program state persistence tests");
        addChild(linkStatusGroup);

        addProgramStateCase<ProgramStateDetachShaderCase>(linkStatusGroup, m_context, "detach_shader", "detach shader");
        addProgramStateCase<ProgramStateReattachShaderCase>(linkStatusGroup, m_context, "reattach_shader",
                                                            "reattach shader");
        addProgramStateCase<ProgramStateDeleteShaderCase>(linkStatusGroup, m_context, "delete_shader", "delete shader");
        addProgramStateCase<ProgramStateReplaceShaderCase>(linkStatusGroup, m_context, "replace_shader",
                                                           "replace shader object");
        addProgramStateCase<ProgramStateRecompileShaderCase>(linkStatusGroup, m_context, "recompile_shader",
                                                             "recompile shader");
        addProgramStateCase<ProgramStateReplaceSourceCase>(linkStatusGroup, m_context, "replace_source",
                                                           "replace shader source");
    }

    // program binary
    {
        TestCaseGroup *programBinaryGroup = new TestCaseGroup(m_context, "program_binary", "Program binary API tests");
        addChild(programBinaryGroup);

        {
            TestCaseGroup *simpleCaseGroup = new TestCaseGroup(m_context, "simple", "Simple API tests");
            programBinaryGroup->addChild(simpleCaseGroup);

            simpleCaseGroup->addChild(new ProgramBinarySimpleCase(m_context, "get_program_binary_vertex_fragment",
                                                                  "Get vertex and fragment shader program binary"));
            simpleCaseGroup->addChild(
                new ProgramBinaryUniformResetCase(m_context, "uniform_reset_on_binary_load",
                                                  "Verify uniform reset on successful load of program binary"));
        }

        {
            TestCaseGroup *binaryPersistenceGroup =
                new TestCaseGroup(m_context, "binary_persistence", "Program binary persistence tests");
            programBinaryGroup->addChild(binaryPersistenceGroup);

            addProgramBinaryPersistenceCase<ProgramBinaryPersistenceDetachShaderCase>(binaryPersistenceGroup, m_context,
                                                                                      "detach_shader", "detach shader");
            addProgramBinaryPersistenceCase<ProgramBinaryPersistenceReattachShaderCase>(
                binaryPersistenceGroup, m_context, "reattach_shader", "reattach shader");
            addProgramBinaryPersistenceCase<ProgramBinaryPersistenceDeleteShaderCase>(binaryPersistenceGroup, m_context,
                                                                                      "delete_shader", "delete shader");
            addProgramBinaryPersistenceCase<ProgramBinaryPersistenceReplaceShaderCase>(
                binaryPersistenceGroup, m_context, "replace_shader", "replace shader object");
            addProgramBinaryPersistenceCase<ProgramBinaryPersistenceRecompileShaderCase>(
                binaryPersistenceGroup, m_context, "recompile_shader", "recompile shader");
            addProgramBinaryPersistenceCase<ProgramBinaryPersistenceReplaceSourceCase>(
                binaryPersistenceGroup, m_context, "replace_source", "replace shader source");
        }
    }
}

} // namespace Functional
} // namespace gles3
} // namespace deqp