xref: /aosp_15_r20/external/deqp/modules/glshared/glsTextureStateQueryTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) 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 Texture State Query tests.
 *//*--------------------------------------------------------------------*/

#include "glsTextureStateQueryTests.hpp"
#include "gluStrUtil.hpp"
#include "gluObjectWrapper.hpp"
#include "gluCallLogWrapper.hpp"
#include "gluContextInfo.hpp"
#include "gluTextureUtil.hpp"
#include "glwEnums.hpp"
#include "deUniquePtr.hpp"
#include "deRandom.hpp"
#include "deStringUtil.hpp"

namespace deqp
{
namespace gls
{
namespace TextureStateQueryTests
{
namespace
{

using namespace glw;
using namespace gls::StateQueryUtil;

static glw::GLenum mapTesterToPname(TesterType tester)
{

#define CASE_ALL_SETTERS(X) \
    case X:                 \
    case X##_SET_PURE_INT:  \
    case X##_SET_PURE_UINT

    switch (tester)
    {
        CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R) : return GL_TEXTURE_SWIZZLE_R;
        CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G) : return GL_TEXTURE_SWIZZLE_G;
        CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B) : return GL_TEXTURE_SWIZZLE_B;
        CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A) : return GL_TEXTURE_SWIZZLE_A;

    CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S) : case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
        return GL_TEXTURE_WRAP_S;

    CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T) : case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
        return GL_TEXTURE_WRAP_T;

    CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R) : case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
        return GL_TEXTURE_WRAP_R;

        CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER) : return GL_TEXTURE_MAG_FILTER;
        CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER) : return GL_TEXTURE_MIN_FILTER;
        CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD) : return GL_TEXTURE_MIN_LOD;
        CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD) : return GL_TEXTURE_MAX_LOD;
        CASE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL) : return GL_TEXTURE_BASE_LEVEL;
        CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL) : return GL_TEXTURE_MAX_LEVEL;
        CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE) : return GL_TEXTURE_COMPARE_MODE;
        CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC) : return GL_TEXTURE_COMPARE_FUNC;
    case TESTER_TEXTURE_IMMUTABLE_LEVELS:
        return GL_TEXTURE_IMMUTABLE_LEVELS;
    case TESTER_TEXTURE_IMMUTABLE_FORMAT:
        return GL_TEXTURE_IMMUTABLE_FORMAT;
        CASE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE) : return GL_DEPTH_STENCIL_TEXTURE_MODE;
        CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT) : return GL_TEXTURE_SRGB_DECODE_EXT;
    case TESTER_TEXTURE_BORDER_COLOR:
        return GL_TEXTURE_BORDER_COLOR;

    default:
        DE_ASSERT(false);
        return -1;
    }

#undef CASE_PURE_SETTERS
}

static bool querySupportsSigned(QueryType type)
{
    return type != QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER && type != QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER;
}

static bool isPureIntTester(TesterType tester)
{
#define HANDLE_ALL_SETTERS(X) \
    case X:                   \
    case X##_SET_PURE_UINT:   \
        return false;         \
    case X##_SET_PURE_INT:    \
        return true;

    switch (tester)
    {
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
        HANDLE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)

    case TESTER_TEXTURE_IMMUTABLE_LEVELS:
    case TESTER_TEXTURE_IMMUTABLE_FORMAT:
    case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_BORDER_COLOR:
        return false;

    default:
        DE_ASSERT(false);
        return false;
    }

#undef HANDLE_ALL_SETTERS
}

static bool isPureUintTester(TesterType tester)
{
#define HANDLE_ALL_SETTERS(X) \
    case X:                   \
    case X##_SET_PURE_INT:    \
        return false;         \
    case X##_SET_PURE_UINT:   \
        return true;

    switch (tester)
    {
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
        HANDLE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
        HANDLE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)

    case TESTER_TEXTURE_IMMUTABLE_LEVELS:
    case TESTER_TEXTURE_IMMUTABLE_FORMAT:
    case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_BORDER_COLOR:
        return false;

    default:
        DE_ASSERT(false);
        return false;
    }

#undef HANDLE_ALL_SETTERS
}

class RequiredExtensions
{
public:
    RequiredExtensions(void)
    {
    }
    explicit RequiredExtensions(const char *ext)
    {
        add(ext);
    }
    RequiredExtensions(const char *extA, const char *extB)
    {
        add(extA);
        add(extB);
    }

    void add(const char *ext);
    void add(const RequiredExtensions &other);
    void check(const glu::ContextInfo &) const;

private:
    std::vector<const char *> m_extensions;
};

void RequiredExtensions::add(const char *ext)
{
    for (int ndx = 0; ndx < (int)m_extensions.size(); ++ndx)
        if (deStringEqual(m_extensions[ndx], ext) == true)
            return;
    m_extensions.push_back(ext);
}

void RequiredExtensions::add(const RequiredExtensions &other)
{
    for (int ndx = 0; ndx < (int)other.m_extensions.size(); ++ndx)
        add(other.m_extensions[ndx]);
}

void RequiredExtensions::check(const glu::ContextInfo &ctxInfo) const
{
    std::vector<const char *> failedExtensions;

    for (int ndx = 0; ndx < (int)m_extensions.size(); ++ndx)
        if (!ctxInfo.isExtensionSupported(m_extensions[ndx]))
            failedExtensions.push_back(m_extensions[ndx]);

    if (!failedExtensions.empty())
    {
        std::ostringstream buf;
        buf << "Test requires extension: ";

        for (int ndx = 0; ndx < (int)failedExtensions.size(); ++ndx)
        {
            if (ndx)
                buf << ", ";
            buf << failedExtensions[ndx];
        }

        throw tcu::NotSupportedError(buf.str());
    }
}

namespace es30
{

static bool isCoreTextureTarget(glw::GLenum target)
{
    return target == GL_TEXTURE_2D || target == GL_TEXTURE_3D || target == GL_TEXTURE_2D_ARRAY ||
           target == GL_TEXTURE_CUBE_MAP;
}

static RequiredExtensions getTextureTargetExtension(glw::GLenum target)
{
    DE_UNREF(target);
    DE_ASSERT(false);
    return RequiredExtensions();
}

static bool isCoreTextureParam(glw::GLenum pname)
{
    return pname == GL_TEXTURE_BASE_LEVEL || pname == GL_TEXTURE_COMPARE_MODE || pname == GL_TEXTURE_COMPARE_FUNC ||
           pname == GL_TEXTURE_MAG_FILTER || pname == GL_TEXTURE_MAX_LEVEL || pname == GL_TEXTURE_MAX_LOD ||
           pname == GL_TEXTURE_MIN_FILTER || pname == GL_TEXTURE_MIN_LOD || pname == GL_TEXTURE_SWIZZLE_R ||
           pname == GL_TEXTURE_SWIZZLE_G || pname == GL_TEXTURE_SWIZZLE_B || pname == GL_TEXTURE_SWIZZLE_A ||
           pname == GL_TEXTURE_WRAP_S || pname == GL_TEXTURE_WRAP_T || pname == GL_TEXTURE_WRAP_R ||
           pname == GL_TEXTURE_IMMUTABLE_FORMAT || pname == GL_TEXTURE_IMMUTABLE_LEVELS;
}

static RequiredExtensions getTextureParamExtension(glw::GLenum pname)
{
    DE_UNREF(pname);
    DE_ASSERT(false);
    return RequiredExtensions();
}

static bool isCoreQuery(QueryType query)
{
    return query == QUERY_TEXTURE_PARAM_INTEGER || query == QUERY_TEXTURE_PARAM_FLOAT ||
           query == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || query == QUERY_TEXTURE_PARAM_FLOAT_VEC4 ||
           query == QUERY_SAMPLER_PARAM_INTEGER || query == QUERY_SAMPLER_PARAM_FLOAT ||
           query == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || query == QUERY_SAMPLER_PARAM_FLOAT_VEC4;
}

static RequiredExtensions getQueryExtension(QueryType query)
{
    DE_UNREF(query);
    DE_ASSERT(false);
    return RequiredExtensions();
}

static bool isCoreTester(TesterType tester)
{
    return tester == TESTER_TEXTURE_SWIZZLE_R || tester == TESTER_TEXTURE_SWIZZLE_G ||
           tester == TESTER_TEXTURE_SWIZZLE_B || tester == TESTER_TEXTURE_SWIZZLE_A ||
           tester == TESTER_TEXTURE_WRAP_S || tester == TESTER_TEXTURE_WRAP_T || tester == TESTER_TEXTURE_WRAP_R ||
           tester == TESTER_TEXTURE_MAG_FILTER || tester == TESTER_TEXTURE_MIN_FILTER ||
           tester == TESTER_TEXTURE_MIN_LOD || tester == TESTER_TEXTURE_MAX_LOD ||
           tester == TESTER_TEXTURE_BASE_LEVEL || tester == TESTER_TEXTURE_MAX_LEVEL ||
           tester == TESTER_TEXTURE_COMPARE_MODE || tester == TESTER_TEXTURE_COMPARE_FUNC ||
           tester == TESTER_TEXTURE_IMMUTABLE_LEVELS || tester == TESTER_TEXTURE_IMMUTABLE_FORMAT;
}

static RequiredExtensions getTesterExtension(TesterType tester)
{
    DE_UNREF(tester);
    DE_ASSERT(false);
    return RequiredExtensions();
}

} // namespace es30

namespace es31
{

static bool isCoreTextureTarget(glw::GLenum target)
{
    return es30::isCoreTextureTarget(target) || target == GL_TEXTURE_2D_MULTISAMPLE;
}

static RequiredExtensions getTextureTargetExtension(glw::GLenum target)
{
    switch (target)
    {
    case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
        return RequiredExtensions("GL_OES_texture_storage_multisample_2d_array");
    case GL_TEXTURE_BUFFER:
        return RequiredExtensions("GL_EXT_texture_buffer");
    case GL_TEXTURE_CUBE_MAP_ARRAY:
        return RequiredExtensions("GL_EXT_texture_cube_map_array");
    default:
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

static bool isCoreTextureParam(glw::GLenum pname)
{
    return es30::isCoreTextureParam(pname) || pname == GL_DEPTH_STENCIL_TEXTURE_MODE;
}

static RequiredExtensions getTextureParamExtension(glw::GLenum pname)
{
    switch (pname)
    {
    case GL_TEXTURE_SRGB_DECODE_EXT:
        return RequiredExtensions("GL_EXT_texture_sRGB_decode");
    case GL_TEXTURE_BORDER_COLOR:
        return RequiredExtensions("GL_EXT_texture_border_clamp");
    default:
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

static bool isCoreQuery(QueryType query)
{
    return es30::isCoreQuery(query);
}

static RequiredExtensions getQueryExtension(QueryType query)
{
    switch (query)
    {
    case QUERY_TEXTURE_PARAM_PURE_INTEGER:
    case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER:
    case QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4:
    case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
    case QUERY_SAMPLER_PARAM_PURE_INTEGER:
    case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER:
    case QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4:
    case QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4:
        return RequiredExtensions("GL_EXT_texture_border_clamp");

    default:
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

static bool isCoreTester(TesterType tester)
{
    return es30::isCoreTester(tester) || tester == TESTER_DEPTH_STENCIL_TEXTURE_MODE;
}

static RequiredExtensions getTesterExtension(TesterType tester)
{
#define CASE_PURE_SETTERS(X) \
    case X##_SET_PURE_INT:   \
    case X##_SET_PURE_UINT

    switch (tester)
    {
    CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_S)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_T)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_WRAP_R)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_MAG_FILTER)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_MIN_FILTER)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_MIN_LOD)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_MAX_LOD)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
        : CASE_PURE_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
        : CASE_PURE_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
        : case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_BORDER_COLOR:
        return RequiredExtensions("GL_EXT_texture_border_clamp");

    case TESTER_TEXTURE_SRGB_DECODE_EXT:
        return RequiredExtensions("GL_EXT_texture_sRGB_decode");

        CASE_PURE_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)
            : return RequiredExtensions("GL_EXT_texture_sRGB_decode", "GL_EXT_texture_border_clamp");

    default:
        DE_ASSERT(false);
        return RequiredExtensions();
    }

#undef CASE_PURE_SETTERS
}

} // namespace es31

namespace es32
{

static bool isCoreTextureTarget(glw::GLenum target)
{
    return es31::isCoreTextureTarget(target) || target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY ||
           target == GL_TEXTURE_BUFFER || target == GL_TEXTURE_CUBE_MAP_ARRAY;
}

static RequiredExtensions getTextureTargetExtension(glw::GLenum target)
{
    DE_UNREF(target);
    DE_ASSERT(false);
    return RequiredExtensions();
}

static bool isCoreTextureParam(glw::GLenum pname)
{
    return es31::isCoreTextureParam(pname) || pname == GL_TEXTURE_BORDER_COLOR;
}

static RequiredExtensions getTextureParamExtension(glw::GLenum pname)
{
    switch (pname)
    {
    case GL_TEXTURE_SRGB_DECODE_EXT:
        return RequiredExtensions("GL_EXT_texture_sRGB_decode");
    default:
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

static bool isCoreQuery(QueryType query)
{
    return es31::isCoreQuery(query) || query == QUERY_TEXTURE_PARAM_PURE_INTEGER ||
           query == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER || query == QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4 ||
           query == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4 || query == QUERY_SAMPLER_PARAM_PURE_INTEGER ||
           query == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER || query == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4 ||
           query == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4;
}

static RequiredExtensions getQueryExtension(QueryType query)
{
    DE_UNREF(query);
    DE_ASSERT(false);
    return RequiredExtensions();
}

static bool isCoreTester(TesterType tester)
{
#define COMPARE_PURE_SETTERS(TESTER, X) ((TESTER) == X##_SET_PURE_INT) || ((TESTER) == X##_SET_PURE_UINT)

    return es31::isCoreTester(tester) || COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_R) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_G) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_B) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_SWIZZLE_A) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_WRAP_S) || COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_WRAP_T) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_WRAP_R) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MAG_FILTER) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MIN_FILTER) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MIN_LOD) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MAX_LOD) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_BASE_LEVEL) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_MAX_LEVEL) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_COMPARE_MODE) ||
           COMPARE_PURE_SETTERS(tester, TESTER_TEXTURE_COMPARE_FUNC) ||
           COMPARE_PURE_SETTERS(tester, TESTER_DEPTH_STENCIL_TEXTURE_MODE) ||
           tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER || tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER ||
           tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER || tester == TESTER_TEXTURE_BORDER_COLOR;

#undef COMPARE_PURE_SETTERS
}

static RequiredExtensions getTesterExtension(TesterType tester)
{
#define CASE_PURE_SETTERS(X) \
    case X##_SET_PURE_INT:   \
    case X##_SET_PURE_UINT

    switch (tester)
    {
    CASE_PURE_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT) : case TESTER_TEXTURE_SRGB_DECODE_EXT:
        return RequiredExtensions("GL_EXT_texture_sRGB_decode");

        default: DE_ASSERT(false);
        return RequiredExtensions();
    }

#undef CASE_PURE_SETTERS
}

} // namespace es32

namespace gl45
{

static bool isCoreTextureTarget(glw::GLenum target)
{
    return es31::isCoreTextureTarget(target);
}

static RequiredExtensions getTextureTargetExtension(glw::GLenum target)
{
    DE_UNREF(target);
    return RequiredExtensions();
}

static bool isCoreTextureParam(glw::GLenum pname)
{
    return es31::isCoreTextureParam(pname);
}

static RequiredExtensions getTextureParamExtension(glw::GLenum pname)
{
    DE_UNREF(pname);
    return RequiredExtensions();
}

static bool isCoreQuery(QueryType query)
{
    return es31::isCoreQuery(query);
}

static RequiredExtensions getQueryExtension(QueryType query)
{
    DE_UNREF(query);
    return RequiredExtensions();
}

static bool isCoreTester(TesterType tester)
{
    return es31::isCoreTester(tester);
}

static RequiredExtensions getTesterExtension(TesterType tester)
{
    DE_UNREF(tester);
    return RequiredExtensions();
}

} // namespace gl45

static bool isCoreTextureTarget(const glu::ContextType &contextType, glw::GLenum target)
{
    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::isCoreTextureTarget(target);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::isCoreTextureTarget(target);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::isCoreTextureTarget(target);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::isCoreTextureTarget(target);
    else
    {
        DE_ASSERT(false);
        return DE_NULL;
    }
}

static bool isCoreTextureParam(const glu::ContextType &contextType, glw::GLenum pname)
{
    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::isCoreTextureParam(pname);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::isCoreTextureParam(pname);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::isCoreTextureParam(pname);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::isCoreTextureParam(pname);
    else
    {
        DE_ASSERT(false);
        return DE_NULL;
    }
}

static bool isCoreQuery(const glu::ContextType &contextType, QueryType query)
{
    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::isCoreQuery(query);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::isCoreQuery(query);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::isCoreQuery(query);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::isCoreQuery(query);
    else
    {
        DE_ASSERT(false);
        return DE_NULL;
    }
}

static bool isCoreTester(const glu::ContextType &contextType, TesterType tester)
{
    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::isCoreTester(tester);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::isCoreTester(tester);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::isCoreTester(tester);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::isCoreTester(tester);
    else
    {
        DE_ASSERT(false);
        return DE_NULL;
    }
}

static RequiredExtensions getTextureTargetExtension(const glu::ContextType &contextType, glw::GLenum target)
{
    DE_ASSERT(!isCoreTextureTarget(contextType, target));

    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::getTextureTargetExtension(target);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::getTextureTargetExtension(target);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::getTextureTargetExtension(target);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::getTextureTargetExtension(target);
    else
    {
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

static RequiredExtensions getTextureParamExtension(const glu::ContextType &contextType, glw::GLenum pname)
{
    DE_ASSERT(!isCoreTextureParam(contextType, pname));

    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::getTextureParamExtension(pname);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::getTextureParamExtension(pname);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::getTextureParamExtension(pname);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::getTextureParamExtension(pname);
    else
    {
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

static RequiredExtensions getQueryExtension(const glu::ContextType &contextType, QueryType query)
{
    DE_ASSERT(!isCoreQuery(contextType, query));

    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::getQueryExtension(query);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::getQueryExtension(query);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::getQueryExtension(query);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::getQueryExtension(query);
    else
    {
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

static RequiredExtensions getTesterExtension(const glu::ContextType &contextType, TesterType tester)
{
    DE_ASSERT(!isCoreTester(contextType, tester));

    if (contextSupports(contextType, glu::ApiType::core(4, 5)))
        return gl45::getTesterExtension(tester);
    else if (contextSupports(contextType, glu::ApiType::es(3, 2)))
        return es32::getTesterExtension(tester);
    else if (contextSupports(contextType, glu::ApiType::es(3, 1)))
        return es31::getTesterExtension(tester);
    else if (contextSupports(contextType, glu::ApiType::es(3, 0)))
        return es30::getTesterExtension(tester);
    else
    {
        DE_ASSERT(false);
        return RequiredExtensions();
    }
}

class TextureTest : public tcu::TestCase
{
public:
    TextureTest(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name, const char *desc,
                glw::GLenum target, TesterType tester, QueryType type);

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

    virtual void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const = 0;

protected:
    const glu::RenderContext &m_renderCtx;
    const glw::GLenum m_target;
    const glw::GLenum m_pname;
    const TesterType m_tester;
    const QueryType m_type;
};

TextureTest::TextureTest(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                         const char *desc, glw::GLenum target, TesterType tester, QueryType type)
    : TestCase(testCtx, name, desc)
    , m_renderCtx(renderCtx)
    , m_target(target)
    , m_pname(mapTesterToPname(tester))
    , m_tester(tester)
    , m_type(type)
{
}

void TextureTest::init(void)
{
    const de::UniquePtr<glu::ContextInfo> ctxInfo(glu::ContextInfo::create(m_renderCtx));
    RequiredExtensions extensions;

    // target
    if (!isCoreTextureTarget(m_renderCtx.getType(), m_target))
        extensions.add(getTextureTargetExtension(m_renderCtx.getType(), m_target));

    // param
    if (!isCoreTextureParam(m_renderCtx.getType(), m_pname))
        extensions.add(getTextureParamExtension(m_renderCtx.getType(), m_pname));

    // query
    if (!isCoreQuery(m_renderCtx.getType(), m_type))
        extensions.add(getQueryExtension(m_renderCtx.getType(), m_type));

    // test type
    if (!isCoreTester(m_renderCtx.getType(), m_tester))
        extensions.add(getTesterExtension(m_renderCtx.getType(), m_tester));

    extensions.check(*ctxInfo);
}

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

    gl.enableLogging(true);
    test(gl, result);

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class IsTextureCase : public tcu::TestCase
{
public:
    IsTextureCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name, const char *desc,
                  glw::GLenum target);

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

protected:
    const glu::RenderContext &m_renderCtx;
    const glw::GLenum m_target;
};

IsTextureCase::IsTextureCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                             const char *desc, glw::GLenum target)
    : tcu::TestCase(testCtx, name, desc)
    , m_renderCtx(renderCtx)
    , m_target(target)
{
}

void IsTextureCase::init(void)
{
    const de::UniquePtr<glu::ContextInfo> ctxInfo(glu::ContextInfo::create(m_renderCtx));
    RequiredExtensions extensions;

    // target
    if (!isCoreTextureTarget(m_renderCtx.getType(), m_target))
        extensions.add(getTextureTargetExtension(m_renderCtx.getType(), m_target));

    extensions.check(*ctxInfo);
}

IsTextureCase::IterateResult IsTextureCase::iterate(void)
{
    glu::CallLogWrapper gl(m_renderCtx.getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    glw::GLuint textureId = 0;

    gl.enableLogging(true);

    gl.glGenTextures(1, &textureId);
    gl.glBindTexture(m_target, textureId);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");

    verifyStateObjectBoolean(result, gl, textureId, true, QUERY_ISTEXTURE);

    gl.glDeleteTextures(1, &textureId);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");

    verifyStateObjectBoolean(result, gl, textureId, false, QUERY_ISTEXTURE);

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class DepthStencilModeCase : public TextureTest
{
public:
    DepthStencilModeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                         const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

DepthStencilModeCase::DepthStencilModeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                           const char *name, const char *desc, glw::GLenum target, TesterType tester,
                                           QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void DepthStencilModeCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    glu::Texture texture(m_renderCtx);

    gl.glBindTexture(m_target, *texture);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind");

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
    }

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Toggle", "Toggle");
        const glw::GLint depthComponentInt     = GL_DEPTH_COMPONENT;
        const glw::GLfloat depthComponentFloat = (glw::GLfloat)GL_DEPTH_COMPONENT;

        gl.glTexParameteri(m_target, m_pname, GL_STENCIL_INDEX);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);

        gl.glTexParameteriv(m_target, m_pname, &depthComponentInt);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);

        gl.glTexParameterf(m_target, m_pname, GL_STENCIL_INDEX);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);

        gl.glTexParameterfv(m_target, m_pname, &depthComponentFloat);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
    }

    if (isPureIntTester(m_tester))
    {
        const glw::GLint depthComponent = GL_DEPTH_COMPONENT;
        const glw::GLint stencilIndex   = GL_STENCIL_INDEX;

        gl.glTexParameterIiv(m_target, m_pname, &stencilIndex);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);

        gl.glTexParameterIiv(m_target, m_pname, &depthComponent);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
    }

    if (isPureUintTester(m_tester))
    {
        const glw::GLuint depthComponent = GL_DEPTH_COMPONENT;
        const glw::GLuint stencilIndex   = GL_STENCIL_INDEX;

        gl.glTexParameterIuiv(m_target, m_pname, &stencilIndex);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_STENCIL_INDEX, m_type);

        gl.glTexParameterIuiv(m_target, m_pname, &depthComponent);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DEPTH_COMPONENT, m_type);
    }
}

class TextureSRGBDecodeCase : public TextureTest
{
public:
    TextureSRGBDecodeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                          const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureSRGBDecodeCase::TextureSRGBDecodeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                             const char *name, const char *desc, glw::GLenum target, TesterType tester,
                                             QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureSRGBDecodeCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    glu::Texture texture(m_renderCtx);

    gl.glBindTexture(m_target, *texture);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "bind");

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Toggle", "Toggle");
        const glw::GLint decodeInt     = GL_DECODE_EXT;
        const glw::GLfloat decodeFloat = (glw::GLfloat)GL_DECODE_EXT;

        gl.glTexParameteri(m_target, m_pname, GL_SKIP_DECODE_EXT);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glTexParameteriv(m_target, m_pname, &decodeInt);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);

        gl.glTexParameterf(m_target, m_pname, GL_SKIP_DECODE_EXT);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glTexParameterfv(m_target, m_pname, &decodeFloat);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }

    if (isPureIntTester(m_tester))
    {
        const glw::GLint skipDecode = GL_SKIP_DECODE_EXT;
        const glw::GLint decode     = GL_DECODE_EXT;

        gl.glTexParameterIiv(m_target, m_pname, &skipDecode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glTexParameterIiv(m_target, m_pname, &decode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }

    if (isPureUintTester(m_tester))
    {
        const glw::GLuint skipDecode = GL_SKIP_DECODE_EXT;
        const glw::GLuint decode     = GL_DECODE_EXT;

        gl.glTexParameterIuiv(m_target, m_pname, &skipDecode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glTexParameterIuiv(m_target, m_pname, &decode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }
}

class TextureSwizzleCase : public TextureTest
{
public:
    TextureSwizzleCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                       const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureSwizzleCase::TextureSwizzleCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                                       const char *desc, glw::GLenum target, TesterType tester, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureSwizzleCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase  = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    const int initialValue = (m_pname == GL_TEXTURE_SWIZZLE_R) ? (GL_RED) :
                             (m_pname == GL_TEXTURE_SWIZZLE_G) ? (GL_GREEN) :
                             (m_pname == GL_TEXTURE_SWIZZLE_B) ? (GL_BLUE) :
                             (m_pname == GL_TEXTURE_SWIZZLE_A) ? (GL_ALPHA) :
                                                                 (-1);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const GLenum swizzleValues[] = {GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_ZERO, GL_ONE};

        if (isPureCase)
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)swizzleValues[ndx];
                    gl.glTexParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = swizzleValues[ndx];
                    gl.glTexParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
                }

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
            {
                gl.glTexParameteri(m_target, m_pname, swizzleValues[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(swizzleValues); ++ndx)
            {
                gl.glTexParameterf(m_target, m_pname, (GLfloat)swizzleValues[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, swizzleValues[ndx], m_type);
            }
        }
    }
}

class TextureWrapCase : public TextureTest
{
public:
    TextureWrapCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                    const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureWrapCase::TextureWrapCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                                 const char *desc, glw::GLenum target, TesterType tester, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureWrapCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_REPEAT, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const GLenum wrapValues[] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};

        if (isPureCase)
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)wrapValues[ndx];
                    gl.glTexParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = wrapValues[ndx];
                    gl.glTexParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
                }

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
            {
                gl.glTexParameteri(m_target, m_pname, wrapValues[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
            {
                gl.glTexParameterf(m_target, m_pname, (GLfloat)wrapValues[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
            }
        }
    }
}

class TextureFilterCase : public TextureTest
{
public:
    TextureFilterCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                      const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureFilterCase::TextureFilterCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                                     const char *desc, glw::GLenum target, TesterType tester, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureFilterCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    glw::GLenum initial   = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR) :
                            (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPMAP_LINEAR) :
                                                                 (0);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, initial, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        std::vector<GLenum> values;

        values.push_back(GL_NEAREST);
        values.push_back(GL_LINEAR);
        if (m_pname == GL_TEXTURE_MIN_FILTER)
        {
            values.push_back(GL_NEAREST_MIPMAP_NEAREST);
            values.push_back(GL_NEAREST_MIPMAP_LINEAR);
            values.push_back(GL_LINEAR_MIPMAP_NEAREST);
            values.push_back(GL_LINEAR_MIPMAP_LINEAR);
        }

        if (isPureCase)
        {
            for (int ndx = 0; ndx < (int)values.size(); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)values[ndx];
                    gl.glTexParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = values[ndx];
                    gl.glTexParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
                }

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < (int)values.size(); ++ndx)
            {
                gl.glTexParameteri(m_target, m_pname, values[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < (int)values.size(); ++ndx)
            {
                gl.glTexParameterf(m_target, m_pname, (GLfloat)values[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
            }
        }
    }
}

class TextureLODCase : public TextureTest
{
public:
    TextureLODCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                   const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureLODCase::TextureLODCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                               const char *desc, glw::GLenum target, TesterType tester, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureLODCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase  = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    const int initialValue = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000) :
                             (m_pname == GL_TEXTURE_MAX_LOD) ? (1000) :
                                                               (-1);

    if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const int numIterations = 20;
        de::Random rnd(0xabcdef);

        if (isPureCase)
        {
            if (isPureIntTester(m_tester))
            {
                for (int ndx = 0; ndx < numIterations; ++ndx)
                {
                    const GLint ref = rnd.getInt(-1000, 1000);

                    gl.glTexParameterIiv(m_target, m_pname, &ref);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");

                    verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
                }
            }
            else
            {
                DE_ASSERT(isPureUintTester(m_tester));

                for (int ndx = 0; ndx < numIterations; ++ndx)
                {
                    const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);

                    gl.glTexParameterIuiv(m_target, m_pname, &ref);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");

                    verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
                }
            }
        }
        else
        {
            const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);

            for (int ndx = 0; ndx < numIterations; ++ndx)
            {
                const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);

                gl.glTexParameterf(m_target, m_pname, ref);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

                verifyStateTextureParamFloat(result, gl, m_target, m_pname, ref, m_type);
            }

            // check unit conversions with int

            for (int ndx = 0; ndx < numIterations; ++ndx)
            {
                const GLint ref = rnd.getInt(minLimit, 1000);

                gl.glTexParameteri(m_target, m_pname, ref);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

                verifyStateTextureParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
            }
        }
    }
}

class TextureLevelCase : public TextureTest
{
public:
    TextureLevelCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                     const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureLevelCase::TextureLevelCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                                   const char *desc, glw::GLenum target, TesterType tester, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureLevelCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase  = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    const int initialValue = (m_pname == GL_TEXTURE_BASE_LEVEL) ? (0) :
                             (m_pname == GL_TEXTURE_MAX_LEVEL)  ? (1000) :
                                                                  (-1);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
    }

    if (m_target == GL_TEXTURE_2D_MULTISAMPLE || m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
    {
        // only 0 allowed
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");

            gl.glTexParameteri(m_target, m_pname, 0);
            GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
            verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);

            gl.glTexParameterf(m_target, m_pname, 0.0f);
            GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");
            verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
        }
    }
    else
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const int numIterations = 20;
        de::Random rnd(0xabcdef);

        if (isPureCase)
        {
            for (int ndx = 0; ndx < numIterations; ++ndx)
            {
                const GLint ref   = rnd.getInt(0, 64000);
                const GLuint uRef = (glw::GLuint)ref;

                if (isPureIntTester(m_tester))
                {
                    gl.glTexParameterIiv(m_target, m_pname, &ref);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));
                    gl.glTexParameterIuiv(m_target, m_pname, &uRef);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
                }

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < numIterations; ++ndx)
            {
                const GLint ref = rnd.getInt(0, 64000);

                gl.glTexParameteri(m_target, m_pname, ref);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
            }

            // check unit conversions with float

            const float nonSignificantOffsets[] = {
                -0.45f, -0.25f, 0,
                0.45f}; // offsets O so that for any integers z in Z, o in O roundToClosestInt(z+o)==z

            const int numConversionIterations = 30;
            for (int ndx = 0; ndx < numConversionIterations; ++ndx)
            {
                const GLint ref = rnd.getInt(1, 64000);

                for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(nonSignificantOffsets); ++offsetNdx)
                {
                    gl.glTexParameterf(m_target, m_pname, ((GLfloat)ref) + nonSignificantOffsets[offsetNdx]);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

                    verifyStateTextureParamInteger(result, gl, m_target, m_pname, ref, m_type);
                }
            }
        }
    }
}

class TextureCompareModeCase : public TextureTest
{
public:
    TextureCompareModeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                           const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureCompareModeCase::TextureCompareModeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                               const char *name, const char *desc, glw::GLenum target,
                                               TesterType tester, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureCompareModeCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const GLenum modes[] = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};

        if (isPureCase)
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)modes[ndx];
                    gl.glTexParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = modes[ndx];
                    gl.glTexParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
                }

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
            {
                gl.glTexParameteri(m_target, m_pname, modes[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
            {
                gl.glTexParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
            }
        }
    }
}

class TextureCompareFuncCase : public TextureTest
{
public:
    TextureCompareFuncCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                           const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureCompareFuncCase::TextureCompareFuncCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                               const char *name, const char *desc, glw::GLenum target,
                                               TesterType tester, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureCompareFuncCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const GLenum compareFuncs[] = {GL_LEQUAL, GL_GEQUAL,   GL_LESS,   GL_GREATER,
                                       GL_EQUAL,  GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};

        if (isPureCase)
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)compareFuncs[ndx];
                    gl.glTexParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = compareFuncs[ndx];
                    gl.glTexParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");
                }

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
            {
                gl.glTexParameteri(m_target, m_pname, compareFuncs[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
            {
                gl.glTexParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

                verifyStateTextureParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
            }
        }
    }
}

class TextureImmutableLevelsCase : public TextureTest
{
public:
    TextureImmutableLevelsCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                               const char *desc, glw::GLenum target, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureImmutableLevelsCase::TextureImmutableLevelsCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                                       const char *name, const char *desc, glw::GLenum target,
                                                       QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_LEVELS, type)
{
}

void TextureImmutableLevelsCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
    }

    if (m_target == GL_TEXTURE_2D_MULTISAMPLE || m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
    {
        // no levels
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Level", "Level");
        GLuint textureID = 0;

        gl.glGenTextures(1, &textureID);
        gl.glBindTexture(m_target, textureID);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");

        if (m_target == GL_TEXTURE_2D_MULTISAMPLE)
            gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
        else if (m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
            gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
        else
            DE_ASSERT(false);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");

        verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);

        gl.glDeleteTextures(1, &textureID);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
    }
    else
    {
        for (int level = 1; level <= 7; ++level)
        {
            const tcu::ScopedLogSection section(m_testCtx.getLog(), "Levels", "Levels = " + de::toString(level));
            GLuint textureID = 0;

            gl.glGenTextures(1, &textureID);
            gl.glBindTexture(m_target, textureID);
            GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");

            if (m_target == GL_TEXTURE_2D || m_target == GL_TEXTURE_CUBE_MAP)
                gl.glTexStorage2D(m_target, level, GL_RGB8, 64, 64);
            else if (m_target == GL_TEXTURE_2D_ARRAY || m_target == GL_TEXTURE_3D)
                gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 64);
            else if (m_target == GL_TEXTURE_CUBE_MAP_ARRAY)
                gl.glTexStorage3D(m_target, level, GL_RGB8, 64, 64, 6 * 2);
            else
                DE_ASSERT(false);
            GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexStorage");

            verifyStateTextureParamInteger(result, gl, m_target, m_pname, level, m_type);

            gl.glDeleteTextures(1, &textureID);
            GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
        }
    }
}

class TextureImmutableFormatCase : public TextureTest
{
public:
    TextureImmutableFormatCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                               const char *desc, glw::GLenum target, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureImmutableFormatCase::TextureImmutableFormatCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                                       const char *name, const char *desc, glw::GLenum target,
                                                       QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_IMMUTABLE_FORMAT, type)
{
}

void TextureImmutableFormatCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);
    }

    {
        const tcu::ScopedLogSection subsection(m_testCtx.getLog(), "Immutable", "Immutable");
        GLuint textureID = 0;

        gl.glGenTextures(1, &textureID);
        gl.glBindTexture(m_target, textureID);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");

        switch (m_target)
        {
        case GL_TEXTURE_2D:
        case GL_TEXTURE_CUBE_MAP:
        {
            gl.glTexStorage2D(m_target, 1, GL_RGBA8, 32, 32);
            break;
        }
        case GL_TEXTURE_2D_ARRAY:
        case GL_TEXTURE_3D:
        {
            gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 8);
            break;
        }
        case GL_TEXTURE_2D_MULTISAMPLE:
        {
            gl.glTexStorage2DMultisample(m_target, 2, GL_RGB8, 64, 64, GL_FALSE);
            break;
        }
        case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
        {
            gl.glTexStorage3DMultisample(m_target, 2, GL_RGB8, 64, 64, 2, GL_FALSE);
            break;
        }
        case GL_TEXTURE_CUBE_MAP_ARRAY:
        {
            gl.glTexStorage3D(m_target, 1, GL_RGBA8, 32, 32, 6 * 2);
            break;
        }
        default:
            DE_ASSERT(false);
        }
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");

        verifyStateTextureParamInteger(result, gl, m_target, m_pname, 1, m_type);

        gl.glDeleteTextures(1, &textureID);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
    }

    // no mutable
    if (m_target == GL_TEXTURE_2D_MULTISAMPLE || m_target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY)
        return;

    // test mutable
    {
        const tcu::ScopedLogSection subsection(m_testCtx.getLog(), "Mutable", "Mutable");
        GLuint textureID = 0;

        gl.glGenTextures(1, &textureID);
        gl.glBindTexture(m_target, textureID);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glBindTexture");

        switch (m_target)
        {
        case GL_TEXTURE_2D:
        {
            gl.glTexImage2D(m_target, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
            break;
        }
        case GL_TEXTURE_CUBE_MAP:
        {
            gl.glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, GL_RGBA8, 32, 32, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
            break;
        }
        case GL_TEXTURE_2D_ARRAY:
        case GL_TEXTURE_3D:
        {
            gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 8, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
            break;
        }
        case GL_TEXTURE_CUBE_MAP_ARRAY:
        {
            gl.glTexImage3D(m_target, 0, GL_RGBA8, 32, 32, 6 * 2, 0, GL_RGBA, GL_UNSIGNED_BYTE, DE_NULL);
            break;
        }
        default:
            DE_ASSERT(false);
        }
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "setup texture");

        verifyStateTextureParamInteger(result, gl, m_target, m_pname, 0, m_type);

        gl.glDeleteTextures(1, &textureID);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glDeleteTextures");
    }
}

class TextureWrapClampToBorderCase : public TextureTest
{
public:
    TextureWrapClampToBorderCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                                 const char *desc, glw::GLenum target, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureWrapClampToBorderCase::TextureWrapClampToBorderCase(tcu::TestContext &testCtx,
                                                           const glu::RenderContext &renderCtx, const char *name,
                                                           const char *desc, glw::GLenum target, TesterType tester,
                                                           QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, tester, type)
{
}

void TextureWrapClampToBorderCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    gl.glTexParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");
    verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);

    gl.glTexParameteri(m_target, m_pname, GL_REPEAT);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteri");

    gl.glTexParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterf");

    verifyStateTextureParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
}

class TextureBorderColorCase : public TextureTest
{
public:
    TextureBorderColorCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                           const char *desc, glw::GLenum target, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

TextureBorderColorCase::TextureBorderColorCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                               const char *name, const char *desc, glw::GLenum target, QueryType type)
    : TextureTest(testCtx, renderCtx, name, desc, target, TESTER_TEXTURE_BORDER_COLOR, type)
{
}

void TextureBorderColorCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    // border color is undefined if queried with pure type and was not set to pure value
    if (m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
    }

    if (m_type == QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const tcu::IVec4 color(0x7FFFFFFF, -2, 3, -128);

        gl.glTexParameterIiv(m_target, m_pname, color.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIiv");

        verifyStateTextureParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
    }
    else if (m_type == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const tcu::UVec4 color(0x8000000ul, 2, 3, 128);

        gl.glTexParameterIuiv(m_target, m_pname, color.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterIuiv");

        verifyStateTextureParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
    }
    else
    {
        DE_ASSERT(m_type == QUERY_TEXTURE_PARAM_INTEGER_VEC4 || m_type == QUERY_TEXTURE_PARAM_FLOAT_VEC4);

        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const tcu::Vec4 color(0.25f, 1.0f, 0.0f, 0.77f);
        const tcu::IVec4 icolor(0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);

        gl.glTexParameterfv(m_target, m_pname, color.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameterfv");

        verifyStateTextureParamFloatVec4(result, gl, m_target, m_pname, color, m_type);

        gl.glTexParameteriv(m_target, m_pname, icolor.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glTexParameteriv");

        verifyStateTextureParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
    }
}

class SamplerTest : public tcu::TestCase
{
public:
    SamplerTest(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name, const char *desc,
                TesterType tester, QueryType type);

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

    virtual void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const = 0;

protected:
    const glu::RenderContext &m_renderCtx;
    const glw::GLenum m_pname;
    const TesterType m_tester;
    const QueryType m_type;
    glw::GLuint m_target;
};

SamplerTest::SamplerTest(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                         const char *desc, TesterType tester, QueryType type)
    : TestCase(testCtx, name, desc)
    , m_renderCtx(renderCtx)
    , m_pname(mapTesterToPname(tester))
    , m_tester(tester)
    , m_type(type)
    , m_target(0)
{
}

void SamplerTest::init(void)
{
    const de::UniquePtr<glu::ContextInfo> ctxInfo(glu::ContextInfo::create(m_renderCtx));
    RequiredExtensions extensions;

    // param
    if (!isCoreTextureParam(m_renderCtx.getType(), m_pname))
        extensions.add(getTextureParamExtension(m_renderCtx.getType(), m_pname));

    // query
    if (!isCoreQuery(m_renderCtx.getType(), m_type))
        extensions.add(getQueryExtension(m_renderCtx.getType(), m_type));

    // test type
    if (!isCoreTester(m_renderCtx.getType(), m_tester))
        extensions.add(getTesterExtension(m_renderCtx.getType(), m_tester));

    extensions.check(*ctxInfo);
}

SamplerTest::IterateResult SamplerTest::iterate(void)
{
    glu::CallLogWrapper gl(m_renderCtx.getFunctions(), m_testCtx.getLog());
    tcu::ResultCollector result(m_testCtx.getLog(), " // ERROR: ");
    glu::Sampler sampler(m_renderCtx);

    gl.enableLogging(true);

    m_target = *sampler;
    test(gl, result);
    m_target = 0;

    result.setTestContextResult(m_testCtx);
    return STOP;
}

class SamplerWrapCase : public SamplerTest
{
public:
    SamplerWrapCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                    const char *desc, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerWrapCase::SamplerWrapCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                                 const char *desc, TesterType tester, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
{
}

void SamplerWrapCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_REPEAT, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const GLenum wrapValues[] = {GL_CLAMP_TO_EDGE, GL_REPEAT, GL_MIRRORED_REPEAT};

        if (isPureCase)
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)wrapValues[ndx];
                    gl.glSamplerParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = wrapValues[ndx];
                    gl.glSamplerParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
                }

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
            {
                gl.glSamplerParameteri(m_target, m_pname, wrapValues[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(wrapValues); ++ndx)
            {
                gl.glSamplerParameterf(m_target, m_pname, (GLfloat)wrapValues[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, wrapValues[ndx], m_type);
            }
        }
    }
}

class SamplerFilterCase : public SamplerTest
{
public:
    SamplerFilterCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                      const char *desc, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerFilterCase::SamplerFilterCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                                     const char *desc, TesterType tester, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
{
}

void SamplerFilterCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase     = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    const glw::GLenum initial = (m_pname == GL_TEXTURE_MAG_FILTER) ? (GL_LINEAR) :
                                (m_pname == GL_TEXTURE_MIN_FILTER) ? (GL_NEAREST_MIPMAP_LINEAR) :
                                                                     (0);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initial, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        std::vector<GLenum> values;

        values.push_back(GL_NEAREST);
        values.push_back(GL_LINEAR);
        if (m_pname == GL_TEXTURE_MIN_FILTER)
        {
            values.push_back(GL_NEAREST_MIPMAP_NEAREST);
            values.push_back(GL_NEAREST_MIPMAP_LINEAR);
            values.push_back(GL_LINEAR_MIPMAP_NEAREST);
            values.push_back(GL_LINEAR_MIPMAP_LINEAR);
        }

        if (isPureCase)
        {
            for (int ndx = 0; ndx < (int)values.size(); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)values[ndx];
                    gl.glSamplerParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = values[ndx];
                    gl.glSamplerParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
                }

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < (int)values.size(); ++ndx)
            {
                gl.glSamplerParameteri(m_target, m_pname, values[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < (int)values.size(); ++ndx)
            {
                gl.glSamplerParameterf(m_target, m_pname, (GLfloat)values[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, values[ndx], m_type);
            }
        }
    }
}

class SamplerLODCase : public SamplerTest
{
public:
    SamplerLODCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                   const char *desc, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerLODCase::SamplerLODCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx, const char *name,
                               const char *desc, TesterType tester, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
{
}

void SamplerLODCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase  = isPureIntTester(m_tester) || isPureUintTester(m_tester);
    const int initialValue = (m_pname == GL_TEXTURE_MIN_LOD) ? (-1000) :
                             (m_pname == GL_TEXTURE_MAX_LOD) ? (1000) :
                                                               (-1);

    if ((querySupportsSigned(m_type) || initialValue >= 0) && !isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, initialValue, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const int numIterations = 20;
        de::Random rnd(0xabcdef);

        if (isPureCase)
        {
            if (isPureIntTester(m_tester))
            {
                for (int ndx = 0; ndx < numIterations; ++ndx)
                {
                    const GLint ref = rnd.getInt(-1000, 1000);

                    gl.glSamplerParameterIiv(m_target, m_pname, &ref);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");

                    verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
                }
            }
            else
            {
                DE_ASSERT(isPureUintTester(m_tester));

                for (int ndx = 0; ndx < numIterations; ++ndx)
                {
                    const GLuint ref = (glw::GLuint)rnd.getInt(0, 1000);

                    gl.glSamplerParameterIuiv(m_target, m_pname, &ref);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");

                    verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
                }
            }
        }
        else
        {
            const int minLimit = (querySupportsSigned(m_type)) ? (-1000) : (0);

            for (int ndx = 0; ndx < numIterations; ++ndx)
            {
                const GLfloat ref = rnd.getFloat((float)minLimit, 1000.f);

                gl.glSamplerParameterf(m_target, m_pname, ref);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");

                verifyStateSamplerParamFloat(result, gl, m_target, m_pname, ref, m_type);
            }

            // check unit conversions with int

            for (int ndx = 0; ndx < numIterations; ++ndx)
            {
                const GLint ref = rnd.getInt(minLimit, 1000);

                gl.glSamplerParameteri(m_target, m_pname, ref);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");

                verifyStateSamplerParamFloat(result, gl, m_target, m_pname, (float)ref, m_type);
            }
        }
    }
}

class SamplerCompareModeCase : public SamplerTest
{
public:
    SamplerCompareModeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                           const char *desc, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerCompareModeCase::SamplerCompareModeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                               const char *name, const char *desc, TesterType tester, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
{
}

void SamplerCompareModeCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_NONE, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const GLenum modes[] = {GL_COMPARE_REF_TO_TEXTURE, GL_NONE};

        if (isPureCase)
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)modes[ndx];
                    gl.glSamplerParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = modes[ndx];
                    gl.glSamplerParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
                }

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
            {
                gl.glSamplerParameteri(m_target, m_pname, modes[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(modes); ++ndx)
            {
                gl.glSamplerParameterf(m_target, m_pname, (GLfloat)modes[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, modes[ndx], m_type);
            }
        }
    }
}

class SamplerCompareFuncCase : public SamplerTest
{
public:
    SamplerCompareFuncCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                           const char *desc, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerCompareFuncCase::SamplerCompareFuncCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                               const char *name, const char *desc, TesterType tester, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
{
}

void SamplerCompareFuncCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_LEQUAL, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const GLenum compareFuncs[] = {GL_LEQUAL, GL_GEQUAL,   GL_LESS,   GL_GREATER,
                                       GL_EQUAL,  GL_NOTEQUAL, GL_ALWAYS, GL_NEVER};

        if (isPureCase)
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
            {
                if (isPureIntTester(m_tester))
                {
                    const glw::GLint value = (glw::GLint)compareFuncs[ndx];
                    gl.glSamplerParameterIiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
                }
                else
                {
                    DE_ASSERT(isPureUintTester(m_tester));

                    const glw::GLuint value = compareFuncs[ndx];
                    gl.glSamplerParameterIuiv(m_target, m_pname, &value);
                    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
                }

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
            }
        }
        else
        {
            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
            {
                gl.glSamplerParameteri(m_target, m_pname, compareFuncs[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
            }

            //check unit conversions with float

            for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(compareFuncs); ++ndx)
            {
                gl.glSamplerParameterf(m_target, m_pname, (GLfloat)compareFuncs[ndx]);
                GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");

                verifyStateSamplerParamInteger(result, gl, m_target, m_pname, compareFuncs[ndx], m_type);
            }
        }
    }
}

class SamplerWrapClampToBorderCase : public SamplerTest
{
public:
    SamplerWrapClampToBorderCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                                 const char *desc, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerWrapClampToBorderCase::SamplerWrapClampToBorderCase(tcu::TestContext &testCtx,
                                                           const glu::RenderContext &renderCtx, const char *name,
                                                           const char *desc, TesterType tester, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
{
}

void SamplerWrapClampToBorderCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    gl.glSamplerParameteri(m_target, m_pname, GL_CLAMP_TO_BORDER_EXT);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");
    verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);

    gl.glSamplerParameteri(m_target, m_pname, GL_REPEAT);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteri");

    gl.glSamplerParameterf(m_target, m_pname, (GLfloat)GL_CLAMP_TO_BORDER_EXT);
    GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterf");

    verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_CLAMP_TO_BORDER_EXT, m_type);
}

class SamplerSRGBDecodeCase : public SamplerTest
{
public:
    SamplerSRGBDecodeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                          const char *desc, TesterType tester, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerSRGBDecodeCase::SamplerSRGBDecodeCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                             const char *name, const char *desc, TesterType tester, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, tester, type)
{
}

void SamplerSRGBDecodeCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    const bool isPureCase = isPureIntTester(m_tester) || isPureUintTester(m_tester);

    if (!isPureCase)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }

    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Toggle", "Toggle");
        const glw::GLint decodeInt     = GL_DECODE_EXT;
        const glw::GLfloat decodeFloat = (glw::GLfloat)GL_DECODE_EXT;

        gl.glSamplerParameteri(m_target, m_pname, GL_SKIP_DECODE_EXT);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glSamplerParameteriv(m_target, m_pname, &decodeInt);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);

        gl.glSamplerParameterf(m_target, m_pname, GL_SKIP_DECODE_EXT);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glSamplerParameterfv(m_target, m_pname, &decodeFloat);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "set state");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }

    if (isPureIntTester(m_tester))
    {
        const glw::GLint skipDecode = GL_SKIP_DECODE_EXT;
        const glw::GLint decode     = GL_DECODE_EXT;

        gl.glSamplerParameterIiv(m_target, m_pname, &skipDecode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glSamplerParameterIiv(m_target, m_pname, &decode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }

    if (isPureUintTester(m_tester))
    {
        const glw::GLuint skipDecode = GL_SKIP_DECODE_EXT;
        const glw::GLuint decode     = GL_DECODE_EXT;

        gl.glSamplerParameterIuiv(m_target, m_pname, &skipDecode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_SKIP_DECODE_EXT, m_type);

        gl.glSamplerParameterIuiv(m_target, m_pname, &decode);
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");
        verifyStateSamplerParamInteger(result, gl, m_target, m_pname, GL_DECODE_EXT, m_type);
    }
}

class SamplerBorderColorCase : public SamplerTest
{
public:
    SamplerBorderColorCase(tcu::TestContext &testCtx, const glu::RenderContext &renderContext, const char *name,
                           const char *desc, QueryType type);
    void test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const;
};

SamplerBorderColorCase::SamplerBorderColorCase(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                               const char *name, const char *desc, QueryType type)
    : SamplerTest(testCtx, renderCtx, name, desc, TESTER_TEXTURE_BORDER_COLOR, type)
{
    DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4 ||
              m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4 ||
              m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4);
}

void SamplerBorderColorCase::test(glu::CallLogWrapper &gl, tcu::ResultCollector &result) const
{
    // border color is undefined if queried with pure type and was not set to pure value
    if (m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Initial", "Initial");
        verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, tcu::Vec4(0.0f, 0.0f, 0.0f, 0.0f), m_type);
    }

    if (m_type == QUERY_SAMPLER_PARAM_PURE_INTEGER_VEC4)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const tcu::IVec4 color(0x7FFFFFFF, -2, 3, -128);

        gl.glSamplerParameterIiv(m_target, m_pname, color.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIiv");

        verifyStateSamplerParamIntegerVec4(result, gl, m_target, m_pname, color, m_type);
    }
    else if (m_type == QUERY_SAMPLER_PARAM_PURE_UNSIGNED_INTEGER_VEC4)
    {
        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const tcu::UVec4 color(0x8000000ul, 2, 3, 128);

        gl.glSamplerParameterIuiv(m_target, m_pname, color.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterIuiv");

        verifyStateSamplerParamUnsignedIntegerVec4(result, gl, m_target, m_pname, color, m_type);
    }
    else
    {
        DE_ASSERT(m_type == QUERY_SAMPLER_PARAM_INTEGER_VEC4 || m_type == QUERY_SAMPLER_PARAM_FLOAT_VEC4);

        const tcu::ScopedLogSection section(m_testCtx.getLog(), "Set", "Set");
        const tcu::Vec4 color(0.25f, 1.0f, 0.0f, 0.77f);
        const tcu::IVec4 icolor(0x8000000ul, 0x7FFFFFFF, 0, 0x0FFFFFFF);

        gl.glSamplerParameterfv(m_target, m_pname, color.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameterfv");

        verifyStateSamplerParamFloatVec4(result, gl, m_target, m_pname, color, m_type);

        gl.glSamplerParameteriv(m_target, m_pname, icolor.getPtr());
        GLS_COLLECT_GL_ERROR(result, gl.glGetError(), "glSamplerParameteriv");

        verifyStateSamplerParamNormalizedI32Vec4(result, gl, m_target, m_pname, icolor, m_type);
    }
}

} // namespace

bool isLegalTesterForTarget(glw::GLenum target, TesterType tester)
{
    // no 3d filtering on 2d targets
    if ((tester == TESTER_TEXTURE_WRAP_R || tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER) && target != GL_TEXTURE_3D)
        return false;

    // no sampling on multisample
    if (isMultisampleTarget(target) && isSamplerStateTester(tester))
        return false;

    // no states in buffer
    if (target == GL_TEXTURE_BUFFER)
        return false;

    return true;
}

bool isMultisampleTarget(glw::GLenum target)
{
    return target == GL_TEXTURE_2D_MULTISAMPLE || target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
}

bool isSamplerStateTester(TesterType tester)
{
    return tester == TESTER_TEXTURE_WRAP_S || tester == TESTER_TEXTURE_WRAP_T || tester == TESTER_TEXTURE_WRAP_R ||
           tester == TESTER_TEXTURE_MAG_FILTER || tester == TESTER_TEXTURE_MIN_FILTER ||
           tester == TESTER_TEXTURE_MIN_LOD || tester == TESTER_TEXTURE_MAX_LOD ||
           tester == TESTER_TEXTURE_COMPARE_MODE || tester == TESTER_TEXTURE_COMPARE_FUNC ||
           tester == TESTER_TEXTURE_SRGB_DECODE_EXT || tester == TESTER_TEXTURE_BORDER_COLOR ||
           tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER || tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER ||
           tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER;
}

tcu::TestCase *createIsTextureTest(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                   const std::string &name, const std::string &description, glw::GLenum target)
{
    return new IsTextureCase(testCtx, renderCtx, name.c_str(), description.c_str(), target);
}

tcu::TestCase *createTexParamTest(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                  const std::string &name, const std::string &description, QueryType queryType,
                                  glw::GLenum target, TesterType tester)
{
    if (isMultisampleTarget(target) && isSamplerStateTester(tester))
    {
        DE_FATAL("Multisample textures have no sampler state");
        return DE_NULL;
    }
    if (target == GL_TEXTURE_BUFFER)
    {
        DE_FATAL("Buffer textures have no texture state");
        return DE_NULL;
    }
    if (target != GL_TEXTURE_3D && mapTesterToPname(tester) == GL_TEXTURE_WRAP_R)
    {
        DE_FATAL("Only 3D textures have wrap r filter");
        return DE_NULL;
    }

#define CASE_ALL_SETTERS(X) \
    case X:                 \
    case X##_SET_PURE_INT:  \
    case X##_SET_PURE_UINT

    switch (tester)
    {
        CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_R)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_G)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_B)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_SWIZZLE_A)
            : return new TextureSwizzleCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                            queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
            : return new TextureWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                         queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
            : return new TextureFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                           queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
            : return new TextureLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                        queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_BASE_LEVEL)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LEVEL)
            : return new TextureLevelCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                          queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
            : return new TextureCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                                queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
            : return new TextureCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                                queryType);

    case TESTER_TEXTURE_IMMUTABLE_LEVELS:
        return new TextureImmutableLevelsCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);

    case TESTER_TEXTURE_IMMUTABLE_FORMAT:
        return new TextureImmutableFormatCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);

    case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
        return new TextureWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                                queryType);

        CASE_ALL_SETTERS(TESTER_DEPTH_STENCIL_TEXTURE_MODE)
            : return new DepthStencilModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                              queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)
            : return new TextureSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, tester,
                                               queryType);

    case TESTER_TEXTURE_BORDER_COLOR:
        return new TextureBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), target, queryType);

    default:
        break;
    }

#undef CASE_ALL_SETTERS

    DE_ASSERT(false);
    return DE_NULL;
}

tcu::TestCase *createSamplerParamTest(tcu::TestContext &testCtx, const glu::RenderContext &renderCtx,
                                      const std::string &name, const std::string &description,
                                      StateQueryUtil::QueryType queryType, TesterType tester)
{
#define CASE_ALL_SETTERS(X) \
    case X:                 \
    case X##_SET_PURE_INT:  \
    case X##_SET_PURE_UINT

    switch (tester)
    {
        CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_S)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_T)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_WRAP_R)
            : return new SamplerWrapCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_MAG_FILTER)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_FILTER)
            : return new SamplerFilterCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_MIN_LOD)
            : CASE_ALL_SETTERS(TESTER_TEXTURE_MAX_LOD)
            : return new SamplerLODCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester, queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_MODE)
            : return new SamplerCompareModeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester,
                                                queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_COMPARE_FUNC)
            : return new SamplerCompareFuncCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester,
                                                queryType);

    case TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER:
    case TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER:
        return new SamplerWrapClampToBorderCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester,
                                                queryType);

        CASE_ALL_SETTERS(TESTER_TEXTURE_SRGB_DECODE_EXT)
            : return new SamplerSRGBDecodeCase(testCtx, renderCtx, name.c_str(), description.c_str(), tester,
                                               queryType);

    case TESTER_TEXTURE_BORDER_COLOR:
        return new SamplerBorderColorCase(testCtx, renderCtx, name.c_str(), description.c_str(), queryType);

    default:
        break;
    }

#undef CASE_ALL_SETTERS

    DE_ASSERT(false);
    return DE_NULL;
}

} // namespace TextureStateQueryTests
} // namespace gls
} // namespace deqp