xref: /aosp_15_r20/external/deqp/modules/gles31/functional/es31fIndexedStateQueryTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.1 Module
 * -------------------------------------------------
 *
 * Copyright 2015 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 Indexed state query tests
 *//*--------------------------------------------------------------------*/

#include "es31fIndexedStateQueryTests.hpp"
#include "tcuTestLog.hpp"
#include "tcuFormatUtil.hpp"
#include "gluRenderContext.hpp"
#include "gluCallLogWrapper.hpp"
#include "gluStrUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluObjectWrapper.hpp"
#include "glwFunctions.hpp"
#include "glwEnums.hpp"
#include "glsStateQueryUtil.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"

namespace deqp
{
namespace gles31
{
namespace Functional
{
namespace
{

using namespace gls::StateQueryUtil;

static const char *getVerifierSuffix(QueryType type)
{
    switch (type)
    {
    case QUERY_INDEXED_BOOLEAN:
        return "getbooleani_v";
    case QUERY_INDEXED_INTEGER:
        return "getintegeri_v";
    case QUERY_INDEXED_INTEGER64:
        return "getinteger64i_v";
    case QUERY_INDEXED_BOOLEAN_VEC4:
        return "getbooleani_v";
    case QUERY_INDEXED_INTEGER_VEC4:
        return "getintegeri_v";
    case QUERY_INDEXED_INTEGER64_VEC4:
        return "getinteger64i_v";
    case QUERY_INDEXED_ISENABLED:
        return "isenabledi";
    default:
        DE_ASSERT(false);
        return DE_NULL;
    }
}

void isExtensionSupported(Context &context, std::string extensionName)
{
    if (contextSupports(context.getRenderContext().getType(), glu::ApiType::core(4, 5)))
        return;

    if (extensionName == "GL_EXT_draw_buffers_indexed" || extensionName == "GL_KHR_blend_equation_advanced")
    {
        if (!contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2)) &&
            !context.getContextInfo().isExtensionSupported(extensionName.c_str()))
            TCU_THROW(NotSupportedError,
                      (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
    }
    else if (!context.getContextInfo().isExtensionSupported(extensionName.c_str()))
        TCU_THROW(NotSupportedError,
                  (std::string("Extension ") + extensionName + std::string(" not supported.")).c_str());
}

class SampleMaskCase : public TestCase
{
public:
    SampleMaskCase(Context &context, const char *name, const char *desc, QueryType verifierType);

private:
    void init(void);
    IterateResult iterate(void);

    const QueryType m_verifierType;
    int m_maxSampleMaskWords;
};

SampleMaskCase::SampleMaskCase(Context &context, const char *name, const char *desc, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
    , m_maxSampleMaskWords(-1)
{
}

void SampleMaskCase::init(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    gl.getIntegerv(GL_MAX_SAMPLE_MASK_WORDS, &m_maxSampleMaskWords);
    GLU_EXPECT_NO_ERROR(gl.getError(), "query sample mask words");

    // mask word count ok?
    if (m_maxSampleMaskWords <= 0)
        throw tcu::TestError("Minimum value of GL_MAX_SAMPLE_MASK_WORDS is 1. Got " +
                             de::toString(m_maxSampleMaskWords));

    m_testCtx.getLog() << tcu::TestLog::Message << "GL_MAX_SAMPLE_MASK_WORDS = " << m_maxSampleMaskWords
                       << tcu::TestLog::EndMessage;
}

SampleMaskCase::IterateResult SampleMaskCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");

    gl.enableLogging(true);

    // initial values
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "initial", "Initial values");

        for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, -1, m_verifierType);
    }

    // fixed values
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "fixed", "Fixed values");

        for (int ndx = 0; ndx < m_maxSampleMaskWords; ++ndx)
        {
            gl.glSampleMaski(ndx, 0);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");

            verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, ndx, 0, m_verifierType);
        }
    }

    // random masks
    {
        const int numRandomTest = 20;
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "random", "Random values");
        de::Random rnd(0x4312);

        for (int testNdx = 0; testNdx < numRandomTest; ++testNdx)
        {
            const glw::GLint maskIndex = (glw::GLint)(rnd.getUint32() % m_maxSampleMaskWords);
            glw::GLint mask            = (glw::GLint)(rnd.getUint32());

            gl.glSampleMaski(maskIndex, mask);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "glSampleMaski");

            verifyStateIndexedInteger(result, gl, GL_SAMPLE_MASK_VALUE, maskIndex, mask, m_verifierType);
        }
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class MinValueIndexed3Case : public TestCase
{
public:
    MinValueIndexed3Case(Context &context, const char *name, const char *desc, glw::GLenum target,
                         const tcu::IVec3 &ref, QueryType verifierType);

private:
    IterateResult iterate(void);

    const glw::GLenum m_target;
    const tcu::IVec3 m_ref;
    const QueryType m_verifierType;
};

MinValueIndexed3Case::MinValueIndexed3Case(Context &context, const char *name, const char *desc, glw::GLenum target,
                                           const tcu::IVec3 &ref, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_target(target)
    , m_ref(ref)
    , m_verifierType(verifierType)
{
}

MinValueIndexed3Case::IterateResult MinValueIndexed3Case::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");

    gl.enableLogging(true);

    for (int ndx = 0; ndx < 3; ++ndx)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Element", "Element " + de::toString(ndx));

        verifyStateIndexedIntegerMin(result, gl, m_target, ndx, m_ref[ndx], m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class BufferBindingCase : public TestCase
{
public:
    BufferBindingCase(Context &context, const char *name, const char *desc, glw::GLenum queryTarget,
                      glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);

private:
    IterateResult iterate(void);

    const glw::GLenum m_queryTarget;
    const glw::GLenum m_bufferTarget;
    const glw::GLenum m_numBindingsTarget;
    const QueryType m_verifierType;
};

BufferBindingCase::BufferBindingCase(Context &context, const char *name, const char *desc, glw::GLenum queryTarget,
                                     glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_queryTarget(queryTarget)
    , m_bufferTarget(bufferTarget)
    , m_numBindingsTarget(numBindingsTarget)
    , m_verifierType(verifierType)
{
}

BufferBindingCase::IterateResult BufferBindingCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxBindings = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxBindings; ++ndx)
            verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Buffer bufferA(m_context.getRenderContext());
        glu::Buffer bufferB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxBindings / 2;

        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");

            gl.glBindBuffer(m_bufferTarget, *bufferA);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBuffer");

            verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
        }
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");

            gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferBase");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
        }
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");

            gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "glBindBufferRange");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, *bufferB, m_verifierType);
        }
        if (ndxA != ndxB)
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, *bufferA, m_verifierType);
        }
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class BufferStartCase : public TestCase
{
public:
    BufferStartCase(Context &context, const char *name, const char *desc, glw::GLenum queryTarget,
                    glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);

private:
    IterateResult iterate(void);

    const glw::GLenum m_queryTarget;
    const glw::GLenum m_bufferTarget;
    const glw::GLenum m_numBindingsTarget;
    const QueryType m_verifierType;
};

BufferStartCase::BufferStartCase(Context &context, const char *name, const char *desc, glw::GLenum queryTarget,
                                 glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_queryTarget(queryTarget)
    , m_bufferTarget(bufferTarget)
    , m_numBindingsTarget(numBindingsTarget)
    , m_verifierType(verifierType)
{
}

BufferStartCase::IterateResult BufferStartCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxBindings = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxBindings; ++ndx)
            verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Buffer bufferA(m_context.getRenderContext());
        glu::Buffer bufferB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxBindings / 2;
        int offset     = -1;

        if (m_bufferTarget == GL_ATOMIC_COUNTER_BUFFER)
            offset = 4;
        else if (m_bufferTarget == GL_SHADER_STORAGE_BUFFER)
        {
            gl.glGetIntegerv(GL_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT, &offset);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "get align");
        }
        else
            DE_ASSERT(false);

        TCU_CHECK(offset >= 0);

        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");

            gl.glBindBuffer(m_bufferTarget, *bufferA);
            gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
            gl.glBindBuffer(m_bufferTarget, *bufferB);
            gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");

            verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
        }
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");

            gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
        }
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");

            gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, offset, 8);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, offset, m_verifierType);
        }
        if (ndxA != ndxB)
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
        }
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class BufferSizeCase : public TestCase
{
public:
    BufferSizeCase(Context &context, const char *name, const char *desc, glw::GLenum queryTarget,
                   glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType);

private:
    IterateResult iterate(void);

    const glw::GLenum m_queryTarget;
    const glw::GLenum m_bufferTarget;
    const glw::GLenum m_numBindingsTarget;
    const QueryType m_verifierType;
};

BufferSizeCase::BufferSizeCase(Context &context, const char *name, const char *desc, glw::GLenum queryTarget,
                               glw::GLenum bufferTarget, glw::GLenum numBindingsTarget, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_queryTarget(queryTarget)
    , m_bufferTarget(bufferTarget)
    , m_numBindingsTarget(numBindingsTarget)
    , m_verifierType(verifierType)
{
}

BufferSizeCase::IterateResult BufferSizeCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxBindings = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(m_numBindingsTarget, &maxBindings);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxBindings; ++ndx)
            verifyStateIndexedInteger(result, gl, m_queryTarget, ndx, 0, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Buffer bufferA(m_context.getRenderContext());
        glu::Buffer bufferB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxBindings / 2;

        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Generic", "After setting generic binding point");

            gl.glBindBuffer(m_bufferTarget, *bufferA);
            gl.glBufferData(m_bufferTarget, 16, DE_NULL, GL_DYNAMIC_READ);
            gl.glBindBuffer(m_bufferTarget, *bufferB);
            gl.glBufferData(m_bufferTarget, 32, DE_NULL, GL_DYNAMIC_READ);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen bufs");

            verifyStateIndexedInteger(result, gl, m_queryTarget, 0, 0, m_verifierType);
        }
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferBase");

            gl.glBindBufferBase(m_bufferTarget, ndxA, *bufferA);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
        }
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Indexed", "After setting with glBindBufferRange");

            gl.glBindBufferRange(m_bufferTarget, ndxB, *bufferB, 0, 8);
            GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind buf");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxB, 8, m_verifierType);
        }
        if (ndxA != ndxB)
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "DifferentStates", "Original state did not change");

            verifyStateIndexedInteger(result, gl, m_queryTarget, ndxA, 0, m_verifierType);
        }
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class ImageBindingNameCase : public TestCase
{
public:
    ImageBindingNameCase(Context &context, const char *name, const char *desc, QueryType verifierType);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

ImageBindingNameCase::ImageBindingNameCase(Context &context, const char *name, const char *desc, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

ImageBindingNameCase::IterateResult ImageBindingNameCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxImages = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxImages; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndx, 0, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Texture textureA(m_context.getRenderContext());
        glu::Texture textureB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxImages / 2;

        gl.glBindTexture(GL_TEXTURE_2D, *textureA);
        gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
        gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxB, *textureB, 0, GL_FALSE, 2, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxA, *textureA, m_verifierType);
        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_NAME, ndxB, *textureB, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class ImageBindingLevelCase : public TestCase
{
public:
    ImageBindingLevelCase(Context &context, const char *name, const char *desc, QueryType verifierType);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

ImageBindingLevelCase::ImageBindingLevelCase(Context &context, const char *name, const char *desc,
                                             QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

ImageBindingLevelCase::IterateResult ImageBindingLevelCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxImages = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxImages; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndx, 0, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Texture textureA(m_context.getRenderContext());
        glu::Texture textureB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxImages / 2;

        gl.glBindTexture(GL_TEXTURE_2D, *textureA);
        gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        gl.glBindTexture(GL_TEXTURE_2D, *textureB);
        gl.glTexStorage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 32, 32);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxB, *textureB, 2, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxA, 0, m_verifierType);
        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LEVEL, ndxB, 2, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class ImageBindingLayeredCase : public TestCase
{
public:
    ImageBindingLayeredCase(Context &context, const char *name, const char *desc, QueryType verifierType);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

ImageBindingLayeredCase::ImageBindingLayeredCase(Context &context, const char *name, const char *desc,
                                                 QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

ImageBindingLayeredCase::IterateResult ImageBindingLayeredCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxImages = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxImages; ++ndx)
            verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndx, false, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Texture textureA(m_context.getRenderContext());
        glu::Texture textureB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxImages / 2;

        gl.glBindTexture(GL_TEXTURE_2D, *textureA);
        gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
        gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxA, false, m_verifierType);
        verifyStateIndexedBoolean(result, gl, GL_IMAGE_BINDING_LAYERED, ndxB, true, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class ImageBindingLayerCase : public TestCase
{
public:
    ImageBindingLayerCase(Context &context, const char *name, const char *desc, QueryType verifierType);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

ImageBindingLayerCase::ImageBindingLayerCase(Context &context, const char *name, const char *desc,
                                             QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

ImageBindingLayerCase::IterateResult ImageBindingLayerCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxImages = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxImages; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndx, 0, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Texture textureA(m_context.getRenderContext());
        glu::Texture textureB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxImages / 2;

        gl.glBindTexture(GL_TEXTURE_2D, *textureA);
        gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
        gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxA, 0, m_verifierType);
        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_LAYER, ndxB, 2, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class ImageBindingAccessCase : public TestCase
{
public:
    ImageBindingAccessCase(Context &context, const char *name, const char *desc, QueryType verifierType);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

ImageBindingAccessCase::ImageBindingAccessCase(Context &context, const char *name, const char *desc,
                                               QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

ImageBindingAccessCase::IterateResult ImageBindingAccessCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxImages = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxImages; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndx, GL_READ_ONLY, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Texture textureA(m_context.getRenderContext());
        glu::Texture textureB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxImages / 2;

        gl.glBindTexture(GL_TEXTURE_2D, *textureA);
        gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
        gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, 32, 32, 4);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxA, GL_READ_ONLY, m_verifierType);
        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_ACCESS, ndxB, GL_READ_WRITE, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class ImageBindingFormatCase : public TestCase
{
public:
    ImageBindingFormatCase(Context &context, const char *name, const char *desc, QueryType verifierType);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

ImageBindingFormatCase::ImageBindingFormatCase(Context &context, const char *name, const char *desc,
                                               QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

ImageBindingFormatCase::IterateResult ImageBindingFormatCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int maxImages = -1;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_IMAGE_UNITS, &maxImages);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxImages; ++ndx)
            if (glu::isContextTypeES(m_context.getRenderContext().getType()))
                verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndx, GL_R32UI, m_verifierType);
            else
                verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndx, GL_R8, m_verifierType);
    }

    {
        const tcu::ScopedLogSection superSection(m_testCtx.getLog(), "AfterSetting", "After setting");
        glu::Texture textureA(m_context.getRenderContext());
        glu::Texture textureB(m_context.getRenderContext());
        const int ndxA = 0;
        const int ndxB = maxImages / 2;

        gl.glBindTexture(GL_TEXTURE_2D, *textureA);
        gl.glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 32, 32);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxA, *textureA, 0, GL_FALSE, 0, GL_READ_ONLY, GL_RGBA8UI);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        gl.glBindTexture(GL_TEXTURE_2D_ARRAY, *textureB);
        gl.glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_R32F, 32, 32, 4);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "gen tex");

        gl.glBindImageTexture(ndxB, *textureB, 0, GL_TRUE, 2, GL_READ_WRITE, GL_R32F);
        GLU_EXPECT_NO_ERROR(gl.glGetError(), "bind unit");

        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxA, GL_RGBA8UI, m_verifierType);
        verifyStateIndexedInteger(result, gl, GL_IMAGE_BINDING_FORMAT, ndxB, GL_R32F, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class ColorMaskCase : public TestCase
{
public:
    ColorMaskCase(Context &context, const char *name, const char *desc, QueryType verifierType);

    void init(void);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

ColorMaskCase::ColorMaskCase(Context &context, const char *name, const char *desc, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

void ColorMaskCase::init(void)
{
    isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}

ColorMaskCase::IterateResult ColorMaskCase::iterate(void)
{
    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int32_t maxDrawBuffers = 0;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(true), m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingCommon", "After setting common");

        gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false),
                                          m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE),
                            (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedBooleanVec4(
                result, gl, GL_COLOR_WRITEMASK, ndx,
                (ndx % 2 == 0 ? tcu::BVec4(true, false, true, false) : tcu::BVec4(false, true, false, true)),
                m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterResettingIndexedWithCommon",
                                            "After resetting indexed with common");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glColorMaski(ndx, (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE),
                            (ndx % 2 == 0 ? GL_TRUE : GL_FALSE), (ndx % 2 == 1 ? GL_TRUE : GL_FALSE));

        gl.glColorMask(GL_FALSE, GL_TRUE, GL_TRUE, GL_FALSE);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedBooleanVec4(result, gl, GL_COLOR_WRITEMASK, ndx, tcu::BVec4(false, true, true, false),
                                          m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class BlendFuncCase : public TestCase
{
public:
    BlendFuncCase(Context &context, const char *name, const char *desc, QueryType verifierType);

    void init(void);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

BlendFuncCase::BlendFuncCase(Context &context, const char *name, const char *desc, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

void BlendFuncCase::init(void)
{
    isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}

BlendFuncCase::IterateResult BlendFuncCase::iterate(void)
{
    const uint32_t blendFuncs[] = {GL_ZERO,
                                   GL_ONE,
                                   GL_SRC_COLOR,
                                   GL_ONE_MINUS_SRC_COLOR,
                                   GL_DST_COLOR,
                                   GL_ONE_MINUS_DST_COLOR,
                                   GL_SRC_ALPHA,
                                   GL_ONE_MINUS_SRC_ALPHA,
                                   GL_DST_ALPHA,
                                   GL_ONE_MINUS_DST_ALPHA,
                                   GL_CONSTANT_COLOR,
                                   GL_ONE_MINUS_CONSTANT_COLOR,
                                   GL_CONSTANT_ALPHA,
                                   GL_ONE_MINUS_CONSTANT_ALPHA,
                                   GL_SRC_ALPHA_SATURATE};

    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int32_t maxDrawBuffers = 0;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_ONE, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ZERO, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_ONE, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ZERO, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingCommon", "After setting common");

        gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingCommonSeparate",
                                            "After setting common separate");

        gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)],
                            blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx,
                                      blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx,
                                      blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx,
                                      blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx,
                                      blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingIndexedSeparate",
                                            "After setting indexed separate");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
                                    blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
                                    blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
                                    blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx,
                                      blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx,
                                      blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx,
                                      blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx,
                                      blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)], m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterResettingIndexedWithCommon",
                                            "After resetting indexed with common");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendFunci(ndx, blendFuncs[ndx % DE_LENGTH_OF_ARRAY(blendFuncs)],
                            blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)]);

        gl.glBlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_DST_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_SRC_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_DST_ALPHA, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate",
                                            "After resetting indexed with common separate");

        gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendFuncSeparatei(ndx, blendFuncs[(ndx + 3) % DE_LENGTH_OF_ARRAY(blendFuncs)],
                                    blendFuncs[(ndx + 2) % DE_LENGTH_OF_ARRAY(blendFuncs)],
                                    blendFuncs[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendFuncs)],
                                    blendFuncs[(ndx + 0) % DE_LENGTH_OF_ARRAY(blendFuncs)]);

        gl.glBlendFuncSeparate(GL_SRC_COLOR, GL_ONE_MINUS_SRC_ALPHA, GL_DST_COLOR, GL_ONE_MINUS_DST_ALPHA);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_RGB, ndx, GL_SRC_COLOR, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_RGB, ndx, GL_ONE_MINUS_SRC_ALPHA, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_SRC_ALPHA, ndx, GL_DST_COLOR, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_DST_ALPHA, ndx, GL_ONE_MINUS_DST_ALPHA, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class BlendEquationCase : public TestCase
{
public:
    BlendEquationCase(Context &context, const char *name, const char *desc, QueryType verifierType);

    void init(void);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

BlendEquationCase::BlendEquationCase(Context &context, const char *name, const char *desc, QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

void BlendEquationCase::init(void)
{
    isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
}

BlendEquationCase::IterateResult BlendEquationCase::iterate(void)
{
    const uint32_t blendEquations[] = {GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX};

    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int32_t maxDrawBuffers = 0;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial value");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_ADD, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_ADD, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingCommon", "After setting common");

        gl.glBlendEquation(GL_FUNC_SUBTRACT);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingCommonSeparate",
                                            "After setting common separate");

        gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx,
                                      blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx,
                                      blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingIndexedSeparate",
                                            "After setting indexed separate");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)],
                                        blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx,
                                      blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx,
                                      blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)], m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterResettingIndexedWithCommon",
                                            "After resetting indexed with common");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendEquationi(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)]);

        gl.glBlendEquation(GL_FUNC_SUBTRACT);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_SUBTRACT, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterResettingIndexedWithCommonSeparate",
                                            "After resetting indexed with common separate");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)],
                                        blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);

        gl.glBlendEquationSeparate(GL_FUNC_REVERSE_SUBTRACT, GL_FUNC_SUBTRACT);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_FUNC_REVERSE_SUBTRACT, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_FUNC_SUBTRACT, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class BlendEquationAdvancedCase : public TestCase
{
public:
    BlendEquationAdvancedCase(Context &context, const char *name, const char *desc, QueryType verifierType);

    void init(void);

private:
    IterateResult iterate(void);

    const QueryType m_verifierType;
};

BlendEquationAdvancedCase::BlendEquationAdvancedCase(Context &context, const char *name, const char *desc,
                                                     QueryType verifierType)
    : TestCase(context, name, desc)
    , m_verifierType(verifierType)
{
}

void BlendEquationAdvancedCase::init(void)
{
    isExtensionSupported(m_context, "GL_EXT_draw_buffers_indexed");
    isExtensionSupported(m_context, "GL_KHR_blend_equation_advanced");
}

BlendEquationAdvancedCase::IterateResult BlendEquationAdvancedCase::iterate(void)
{
    const uint32_t blendEquations[] = {GL_FUNC_ADD, GL_FUNC_SUBTRACT, GL_FUNC_REVERSE_SUBTRACT, GL_MIN, GL_MAX};

    const uint32_t blendEquationAdvanced[] = {GL_MULTIPLY,       GL_SCREEN,     GL_OVERLAY,       GL_DARKEN,
                                              GL_LIGHTEN,        GL_COLORDODGE, GL_COLORBURN,     GL_HARDLIGHT,
                                              GL_SOFTLIGHT,      GL_DIFFERENCE, GL_EXCLUSION,     GL_HSL_HUE,
                                              GL_HSL_SATURATION, GL_HSL_COLOR,  GL_HSL_LUMINOSITY};

    glu::CallLogWrapper gl(m_context.getRenderContext().getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    int32_t maxDrawBuffers = 0;

    gl.enableLogging(true);

    gl.glGetIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
    GLU_EXPECT_NO_ERROR(gl.glGetError(), "glGetIntegerv");

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingCommon", "After setting common");

        gl.glBlendEquation(GL_SCREEN);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_SCREEN, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_SCREEN, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterSettingIndexed", "After setting indexed");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx,
                                      blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)],
                                      m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx,
                                      blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)],
                                      m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterResettingIndexedWithCommon",
                                            "After resetting indexed with common");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendEquationi(ndx, blendEquationAdvanced[ndx % DE_LENGTH_OF_ARRAY(blendEquationAdvanced)]);

        gl.glBlendEquation(GL_MULTIPLY);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_MULTIPLY, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_MULTIPLY, m_verifierType);
    }
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "AfterResettingIndexedSeparateWithCommon",
                                            "After resetting indexed separate with common");

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            gl.glBlendEquationSeparatei(ndx, blendEquations[ndx % DE_LENGTH_OF_ARRAY(blendEquations)],
                                        blendEquations[(ndx + 1) % DE_LENGTH_OF_ARRAY(blendEquations)]);

        gl.glBlendEquation(GL_LIGHTEN);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_RGB, ndx, GL_LIGHTEN, m_verifierType);

        for (int ndx = 0; ndx < maxDrawBuffers; ++ndx)
            verifyStateIndexedInteger(result, gl, GL_BLEND_EQUATION_ALPHA, ndx, GL_LIGHTEN, m_verifierType);
    }

    result.setTestContextResult(m_testCtx);
    return STOP;
}

} // namespace

IndexedStateQueryTests::IndexedStateQueryTests(Context &context)
    : TestCaseGroup(context, "indexed", "Indexed state queries")
{
}

IndexedStateQueryTests::~IndexedStateQueryTests(void)
{
}

void IndexedStateQueryTests::init(void)
{
    static const QueryType verifiers[] = {QUERY_INDEXED_BOOLEAN, QUERY_INDEXED_INTEGER, QUERY_INDEXED_INTEGER64};

#define FOR_EACH_VERIFIER(X)                                                              \
    for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(verifiers); ++verifierNdx) \
    {                                                                                     \
        const QueryType verifier   = verifiers[verifierNdx];                              \
        const char *verifierSuffix = getVerifierSuffix(verifier);                         \
        this->addChild(X);                                                                \
    }

    FOR_EACH_VERIFIER(new SampleMaskCase(m_context, (std::string() + "sample_mask_value_" + verifierSuffix).c_str(),
                                         "Test SAMPLE_MASK_VALUE", verifier))

    FOR_EACH_VERIFIER(
        new MinValueIndexed3Case(m_context, (std::string() + "max_compute_work_group_count_" + verifierSuffix).c_str(),
                                 "Test MAX_COMPUTE_WORK_GROUP_COUNT", GL_MAX_COMPUTE_WORK_GROUP_COUNT,
                                 tcu::IVec3(65535, 65535, 65535), verifier))
    FOR_EACH_VERIFIER(new MinValueIndexed3Case(
        m_context, (std::string() + "max_compute_work_group_size_" + verifierSuffix).c_str(),
        "Test MAX_COMPUTE_WORK_GROUP_SIZE", GL_MAX_COMPUTE_WORK_GROUP_SIZE, tcu::IVec3(128, 128, 64), verifier))

    FOR_EACH_VERIFIER(new BufferBindingCase(m_context,
                                            (std::string() + "atomic_counter_buffer_binding_" + verifierSuffix).c_str(),
                                            "Test ATOMIC_COUNTER_BUFFER_BINDING", GL_ATOMIC_COUNTER_BUFFER_BINDING,
                                            GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
    FOR_EACH_VERIFIER(new BufferStartCase(m_context,
                                          (std::string() + "atomic_counter_buffer_start_" + verifierSuffix).c_str(),
                                          "Test ATOMIC_COUNTER_BUFFER_START", GL_ATOMIC_COUNTER_BUFFER_START,
                                          GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))
    FOR_EACH_VERIFIER(new BufferSizeCase(m_context,
                                         (std::string() + "atomic_counter_buffer_size_" + verifierSuffix).c_str(),
                                         "Test ATOMIC_COUNTER_BUFFER_SIZE", GL_ATOMIC_COUNTER_BUFFER_SIZE,
                                         GL_ATOMIC_COUNTER_BUFFER, GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, verifier))

    FOR_EACH_VERIFIER(new BufferBindingCase(m_context,
                                            (std::string() + "shader_storage_buffer_binding_" + verifierSuffix).c_str(),
                                            "Test SHADER_STORAGE_BUFFER_BINDING", GL_SHADER_STORAGE_BUFFER_BINDING,
                                            GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
    FOR_EACH_VERIFIER(new BufferStartCase(m_context,
                                          (std::string() + "shader_storage_buffer_start_" + verifierSuffix).c_str(),
                                          "Test SHADER_STORAGE_BUFFER_START", GL_SHADER_STORAGE_BUFFER_START,
                                          GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))
    FOR_EACH_VERIFIER(new BufferSizeCase(m_context,
                                         (std::string() + "shader_storage_buffer_size_" + verifierSuffix).c_str(),
                                         "Test SHADER_STORAGE_BUFFER_SIZE", GL_SHADER_STORAGE_BUFFER_SIZE,
                                         GL_SHADER_STORAGE_BUFFER, GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS, verifier))

    FOR_EACH_VERIFIER(new ImageBindingNameCase(m_context,
                                               (std::string() + "image_binding_name_" + verifierSuffix).c_str(),
                                               "Test IMAGE_BINDING_NAME", verifier))
    FOR_EACH_VERIFIER(new ImageBindingLevelCase(m_context,
                                                (std::string() + "image_binding_level_" + verifierSuffix).c_str(),
                                                "Test IMAGE_BINDING_LEVEL", verifier))
    FOR_EACH_VERIFIER(new ImageBindingLayeredCase(m_context,
                                                  (std::string() + "image_binding_layered_" + verifierSuffix).c_str(),
                                                  "Test IMAGE_BINDING_LAYERED", verifier))
    FOR_EACH_VERIFIER(new ImageBindingLayerCase(m_context,
                                                (std::string() + "image_binding_layer_" + verifierSuffix).c_str(),
                                                "Test IMAGE_BINDING_LAYER", verifier))
    FOR_EACH_VERIFIER(new ImageBindingAccessCase(m_context,
                                                 (std::string() + "image_binding_access_" + verifierSuffix).c_str(),
                                                 "Test IMAGE_BINDING_ACCESS", verifier))
    FOR_EACH_VERIFIER(new ImageBindingFormatCase(m_context,
                                                 (std::string() + "image_binding_format_" + verifierSuffix).c_str(),
                                                 "Test IMAGE_BINDING_FORMAT", verifier))

    // All non-boolean verifiers are tested in ES3 test module.
    addChild(new ColorMaskCase(m_context, "color_mask_getbooleani_v", "COLOR_WRITEMASK", QUERY_INDEXED_BOOLEAN_VEC4));
    addChild(
        new BlendFuncCase(m_context, "blend_func_getbooleani_v", "BLEND_SRC and BLEND_DST", QUERY_INDEXED_BOOLEAN));
    addChild(new BlendEquationCase(m_context, "blend_equation_getbooleani_v", "BLEND_EQUATION_RGB and BLEND_DST",
                                   QUERY_INDEXED_BOOLEAN));
    addChild(new BlendEquationAdvancedCase(m_context, "blend_equation_advanced_getbooleani_v",
                                           "BLEND_EQUATION_RGB and BLEND_DST", QUERY_INDEXED_BOOLEAN));

#undef FOR_EACH_VEC4_VERIFIER
#undef FOR_EACH_VERIFIER
}

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