xref: /aosp_15_r20/external/deqp/external/openglcts/modules/gl/gl4cDirectStateAccessTests.hpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

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

/**
 */ /*!
 * \file  gl4cDirectStateAccessTests.hpp
 * \brief Conformance tests for the Direct State Access feature functionality.
 */ /*-----------------------------------------------------------------------------*/

/* Includes. */

#include "glcTestCase.hpp"
#include "glwDefs.hpp"
#include "tcuDefs.hpp"

#include <string>
#include <typeinfo>

namespace gl4cts
{
namespace DirectStateAccess
{
/** @class Tests
 *
 *  @brief Direct State Access test group.
 */
class Tests : public deqp::TestCaseGroup
{
public:
    /* Public member functions */
    Tests(deqp::Context &context);

    void init();

private:
    /* Private member functions */
    Tests(const Tests &other);
    Tests &operator=(const Tests &other);
};
/* Tests class */

/* Direct State Access Feature Interfaces */

/* Direct State Access Transform Feedback Tests */
namespace TransformFeedback
{
/** @class CreationTest
 *
 *  @brief Direct State Access Transform Feedback Creation test cases.
 *
 *  Test follows the steps:
 *
 *      Create at least two transform feedback objects names with
 *      GenTransformFeedbacks function. Check them without binding, using
 *      IsTransformFeedback function. Expect GL_FALSE.
 *
 *      Create at least two transform feedback objects with
 *      CreateTransformFeedbacks function. Check them without binding, using
 *      IsTransformFeedback function. Expect GL_TRUE.
 *
 *      Check that transform feedback binding point is unchanged.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** @class DefaultsTest
 *
 *  @brief Direct State Access Transform Feedback Default State test cases.
 *
 *  Test follows the steps:
 *
 *       Create transform feedback object with CreateTransformFeedbacks function.
 *
 *      Query parameters TRANSFORM_FEEDBACK_BUFFER_BINDING using
 *      GetTransformFeedbacki_v for all available indexed binding points. For
 *      all queries, expect value equal to 0.
 *
 *      Query parameters:
 *       -  TRANSFORM_FEEDBACK_BUFFER_START and
 *       -  TRANSFORM_FEEDBACK_BUFFER_SIZE
 *      using GetTransformFeedbacki64_v for all available indexed binding
 *      points. For all queries, expect value equal to 0.
 *
 *      Query parameters:
 *       -  TRANSFORM_FEEDBACK_PAUSED and
 *       -  TRANSFORM_FEEDBACK_ACTIVE
 *      using GetTransformFeedbackiv. For all queries, expect value equal to
 *      FALSE.
 */
class DefaultsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DefaultsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DefaultsTest(const DefaultsTest &other);
    DefaultsTest &operator=(const DefaultsTest &other);

    /* Function pointers type definitions and declarations. */
    typedef void(GLW_APIENTRY *GetTransformFeedbackiv_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                   glw::GLint *param);
    typedef void(GLW_APIENTRY *GetTransformFeedbacki_v_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                    glw::GLuint index, glw::GLint *param);
    typedef void(GLW_APIENTRY *GetTransformFeedbacki64_v_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                      glw::GLuint index, glw::GLint64 *param);

    GetTransformFeedbackiv_ProcAddress m_gl_getTransformFeedbackiv;
    GetTransformFeedbacki_v_ProcAddress m_gl_getTransformFeedbacki_v;
    GetTransformFeedbacki64_v_ProcAddress m_gl_getTransformFeedbacki64_v;

    /* Private member variables */
    glw::GLuint m_xfb_dsa;
    glw::GLint m_xfb_indexed_binding_points_count;

    /* Private member functions. */
    void prepare();
    bool testBuffersBindingPoints();
    bool testBuffersDimensions();
    bool testActive();
    bool testPaused();
    void clean();
};
/* DefaultsTest class */

/** @class BuffersTest
 *
 *  @brief Direct State Access Transform Feedback Buffer Objects binding test cases.
 *         The test follows the steps:
 *
 *             Create transform feedback object with CreateTransformFeedbacks function.
 *
 *             Create two buffer objects using GenBuffers and BindBuffer functions.
 *             Allocate storage for them using BufferData.
 *
 *             Bind the first buffer to transform feedback object indexed binding point
 *             0 using TransformFeedbackBufferBase function.
 *
 *             Bind a first half of the second buffer to transform feedback object
 *             indexed binding point 1 using TransformFeedbackBufferRange.
 *
 *             Bind a second half of the second buffer to transform feedback object
 *             indexed binding point 12 using TransformFeedbackBufferRange.
 *
 *             Query parameter TRANSFORM_FEEDBACK_BUFFER_BINDING using
 *             GetTransformFeedbacki_v for all 1st, 2nd and 3rd indexed binding point.
 *             For all queries, expect value equal to the corresponding buffers'
 *             identifiers.
 *
 *             Query parameters:
 *              -  TRANSFORM_FEEDBACK_BUFFER_START and
 *              -  TRANSFORM_FEEDBACK_BUFFER_SIZE
 *             using GetTransformFeedbacki64_v for indexed binding points 0, 1 and 2.
 *             Verify returned values.
 */
class BuffersTest : public deqp::TestCase
{
public:
    /* Public member functions */
    BuffersTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    BuffersTest(const BuffersTest &other);
    BuffersTest &operator=(const BuffersTest &other);

    /* Function pointers type definitions and declarations. */
    typedef void(GLW_APIENTRY *GetTransformFeedbacki_v_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                    glw::GLuint index, glw::GLint *param);
    typedef void(GLW_APIENTRY *GetTransformFeedbacki64_v_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                      glw::GLuint index, glw::GLint64 *param);
    typedef void(GLW_APIENTRY *TransformFeedbackBufferBase_ProcAddress)(glw::GLuint xfb, glw::GLuint index,
                                                                        glw::GLuint buffer);
    typedef void(GLW_APIENTRY *TransformFeedbackBufferRange_ProcAddress)(glw::GLuint xfb, glw::GLuint index,
                                                                         glw::GLuint buffer, glw::GLintptr offset,
                                                                         glw::GLsizeiptr size);

    GetTransformFeedbacki_v_ProcAddress m_gl_getTransformFeedbacki_v;
    GetTransformFeedbacki64_v_ProcAddress m_gl_getTransformFeedbacki64_v;
    TransformFeedbackBufferBase_ProcAddress m_gl_TransformFeedbackBufferBase;
    TransformFeedbackBufferRange_ProcAddress m_gl_TransformFeedbackBufferRange;

    /* Private member variables */
    glw::GLuint m_xfb_dsa;
    glw::GLuint m_bo_a;
    glw::GLuint m_bo_b;

    /* Private static variables */
    static const glw::GLuint s_bo_size;

    /* Private member functions. */
    void prepareObjects();
    bool prepareTestSetup();
    bool testBindingPoint(glw::GLuint const index, glw::GLint const expected_value,
                          glw::GLchar const *const tested_function_name);
    bool testStart(glw::GLuint const index, glw::GLint const expected_value,
                   glw::GLchar const *const tested_function_name);
    bool testSize(glw::GLuint const index, glw::GLint const expected_value,
                  glw::GLchar const *const tested_function_name);
    void clean();
};
/* BuffersTest class */

/** @class ErrorsTest
 *
 *  @brief Direct State Access Transform Feedback Negative test cases.
 *         The test follows steps:
 *
 *              Check that CreateTransformFeedbacks generates INVALID_VALUE error if
 *              number of transform feedback objects to create is negative.
 *
 *              Check that GetTransformFeedbackiv, GetTransformFeedbacki_v and
 *              GetTransformFeedbacki64_v generate INVALID_OPERATION error if xfb is not
 *              zero or the name of an existing transform feedback object.
 *
 *              Check that GetTransformFeedbackiv generates INVALID_ENUM error if pname
 *              is not TRANSFORM_FEEDBACK_PAUSED or TRANSFORM_FEEDBACK_ACTIVE.
 *
 *              Check that GetTransformFeedbacki_v generates INVALID_ENUM error if pname
 *              is not TRANSFORM_FEEDBACK_BUFFER_BINDING.
 *
 *              Check that GetTransformFeedbacki64_v generates INVALID_ENUM error if
 *              pname is not TRANSFORM_FEEDBACK_BUFFER_START or
 *              TRANSFORM_FEEDBACK_BUFFER_SIZE.
 *
 *              Check that GetTransformFeedbacki_v and GetTransformFeedbacki64_v
 *              generate INVALID_VALUE error by GetTransformFeedbacki_v and
 *              GetTransformFeedbacki64_v if index is greater than or equal to the
 *              number of binding points for transform feedback (the value of
 *              MAX_TRANSFORM_FEEDBACK_BUFFERS).
 */
class ErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ErrorsTest(const ErrorsTest &other);
    ErrorsTest &operator=(const ErrorsTest &other);

    /* Function pointers type definitions and declarations. */
    typedef void(GLW_APIENTRY *GetTransformFeedbackiv_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                   glw::GLint *param);
    typedef void(GLW_APIENTRY *GetTransformFeedbacki_v_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                    glw::GLuint index, glw::GLint *param);
    typedef void(GLW_APIENTRY *GetTransformFeedbacki64_v_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                      glw::GLuint index, glw::GLint64 *param);

    GetTransformFeedbackiv_ProcAddress m_gl_getTransformFeedbackiv;
    GetTransformFeedbacki_v_ProcAddress m_gl_getTransformFeedbacki_v;
    GetTransformFeedbacki64_v_ProcAddress m_gl_getTransformFeedbacki64_v;

    /* Private member functions. */
    void prepareFunctionPointers();
    void cleanErrors();

    bool testCreateTransformFeedbacksForInvalidNumberOfObjects();
    bool testQueriesForInvalidNameOfObject();
    bool testGetTransformFeedbackivQueryForInvalidParameterName();
    bool testGetTransformFeedbacki_vQueryForInvalidParameterName();
    bool testGetTransformFeedbacki64_vQueryForInvalidParameterName();
    bool testIndexedQueriesForInvalidBindingPoint();
};
/* BuffersTest class */

/** @class FunctionalTest
 *
 *  @brief Direct State Access Transform Feedback Functional test cases.
 *
 *  @note  The test follows steps:
 *
 *             Create transform feedback object with CreateTransformFeedbacks function.
 *
 *             Create buffer object using GenBuffers and BindBuffer functions.
 *             Allocate storage for it using BufferData.
 *
 *             Bind the buffer to transform feedback object indexed binding point 0
 *             using TransformFeedbackBufferBase function.
 *
 *             Prepare program with vertex shader which outputs VertexID to transform
 *             feedback varying.
 *
 *             Create and bind empty vertex array object.
 *
 *             Begin transform feedback environment.
 *
 *             Using the program with discarded rasterizer, draw array of 4 indices
 *             using POINTS.
 *
 *             Pause transform feedback environment.
 *
 *             Query parameter TRANSFORM_FEEDBACK_PAUSED using GetTransformFeedbackiv.
 *             Expect value equal to TRUE.
 *
 *             Query parameter TRANSFORM_FEEDBACK_PAUSED using GetTransformFeedbackiv.
 *             Expect value equal to FALSE.
 *
 *             Resume transform feedback environment.
 *
 *             Query parameter TRANSFORM_FEEDBACK_PAUSED using GetTransformFeedbackiv.
 *             Expect value equal to FALSE.
 *
 *             Query parameter TRANSFORM_FEEDBACK_PAUSED using GetTransformFeedbackiv.
 *             Expect value equal to TRUE.
 *
 *             End Transform feedback environment.
 *
 *             Verify data in the buffer using MapBuffer function.
 */
class FunctionalTest : public deqp::TestCase
{
public:
    /* Public member functions */
    FunctionalTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    FunctionalTest(const FunctionalTest &other);
    FunctionalTest &operator=(const FunctionalTest &other);

    /* Function pointers type definitions and declarations. */
    typedef void(GLW_APIENTRY *GetTransformFeedbackiv_ProcAddress)(glw::GLuint xfb, glw::GLenum pname,
                                                                   glw::GLint *param);
    typedef void(GLW_APIENTRY *TransformFeedbackBufferBase_ProcAddress)(glw::GLuint xfb, glw::GLuint index,
                                                                        glw::GLuint buffer);

    GetTransformFeedbackiv_ProcAddress m_gl_getTransformFeedbackiv;
    TransformFeedbackBufferBase_ProcAddress m_gl_TransformFeedbackBufferBase;

    /* Private member variables. */
    glw::GLuint m_xfb_dsa;
    glw::GLuint m_bo;
    glw::GLuint m_po;
    glw::GLuint m_vao;

    /* Private member functions. */
    void prepareFunctionPointers();
    void prepareTransformFeedback();
    void prepareBuffer();
    void prepareProgram();
    void prepareVertexArrayObject();

    bool draw();
    bool testTransformFeedbackStatus(glw::GLenum parameter_name, glw::GLint expected_value);
    bool verifyBufferContent();

    void clean();

    /* Private static variables. */
    static const glw::GLuint s_bo_size;
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
    static const glw::GLchar *const s_xfb_varying;
};
/* FunctionalTest class */
} // namespace TransformFeedback

namespace Samplers
{
/** @class CreationTest
 *
 *  @brief Direct State Access Sampler Objects Creation test cases.
 *
 *  Test follows the steps:
 *
 *       Create at least two Sampler Objects names using GenSamplers function.
 *       Check them without binding, using IsSampler function. Expect GL_FALSE.
 *
 *       Create at least two Sampler Objects using CreateSamplers function. Check
 *       them without binding, using IsSampler function. Expect GL_TRUE.
 *
 *       Release objects.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** @class DefaultsTest
 *
 *  @brief Direct State Access Sampler Objects Default State test.
 *
 *         Test follows the steps:
 *
 *             Create Sampler Object with CreateSamplers function.
 *
 *             Verify that default value of TEXTURE_BORDER_COLOR queried with function
 *             GetSamplerParameterfv is 0.0, 0.0, 0.0, 0.0.
 *
 *             Verify that default value of TEXTURE_COMPARE_FUNC queried with function
 *             GetSamplerParameteriv is LEQUAL.
 *
 *             Verify that default value of TEXTURE_COMPARE_MODE queried with function
 *             GetSamplerParameteriv is NONE.
 *
 *             Verify that default value of TEXTURE_LOD_BIAS queried with function
 *             GetSamplerParameterfv is 0.0.
 *
 *             Verify that default value of TEXTURE_MAX_LOD queried with function
 *             GetSamplerParameterfv is 1000.
 *
 *             Verify that default value of TEXTURE_MAG_FILTER queried with function
 *             GetSamplerParameteriv is LINEAR.
 *
 *             Verify that default value of TEXTURE_MIN_FILTER queried with function
 *             GetSamplerParameteriv is NEAREST_MIPMAP_LINEAR.
 *
 *             Verify that default value of TEXTURE_MIN_LOD queried with function
 *             GetSamplerParameterfv is -1000.
 *
 *             Verify that default value of TEXTURE_WRAP_S queried with function
 *             GetSamplerParameteriv is REPEAT.
 *
 *             Verify that default value of TEXTURE_WRAP_T queried with function
 *             GetSamplerParameteriv is REPEAT.
 *
 *             Verify that default value of TEXTURE_WRAP_R queried with function
 *             GetSamplerParameteriv is REPEAT.
 *
 *             Release objects.
 */
class DefaultsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DefaultsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DefaultsTest(const DefaultsTest &other);
    DefaultsTest &operator=(const DefaultsTest &other);

    /* Private member variables */
    glw::GLuint m_sampler_dsa;

    /* Private member functions. */
    void prepare();
    bool testSamplerIntegerParameter(glw::GLenum pname, glw::GLint expected_value);
    bool testSamplerFloatParameter(glw::GLenum pname, glw::GLfloat expected_value);
    bool testSamplerFloatVectorParameter(glw::GLenum pname, glw::GLfloat expected_value[4]);
    void clean();
};
/* DefaultsTest class */

/** @class ErrorsTest
 *
 *  @brief Direct State Access Samplers Negative test.
 *
 *         The test follows steps:
 *
 *             Check that CreateSamplers generates INVALID_VALUE error if
 *             number of sampler objects to create is negative.
 */
class ErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ErrorsTest(const ErrorsTest &other);
    ErrorsTest &operator=(const ErrorsTest &other);
};
/* ErrorsTest class */

/** @class FunctionalTest
 *
 *  @brief Direct State Access Samplers Functional test cases.
 *
 *  @note  The test follows steps:
 *
 *             Create framebuffer with renderbuffer with color attachment and 1x1 pixel
 *             size. Clean framebuffer content with black color.
 *
 *             Create and bind empty vertex array object.
 *
 *             Build and use simple GLSL program drawing full screen textured quad
 *             depending on VertexID. Fragment shader shall output texture point at
 *             (1/3, 1/3).
 *
 *             Create texture 2 x 2 texels in size. Bind it. Upload texture with
 *             following color data:
 *                 RED,    GREEN,
 *                 BLUE,   YELLOW.
 *
 *             Create Sampler object using CreateSamplers function and bind it to the
 *             texture unit. Setup following sampler parameters:
 *              *  TEXTURE_WRAP_S to the value of REPEAT,
 *              *  TEXTURE_WRAP_T to REPEAT,
 *              *  TEXTURE_MIN_FILTER to NEAREST,
 *              *  TEXTURE_MAG_FILTER to NEAREST.
 *
 *             Draw full screen quad.
 *
 *             Fetch framebuffer content with ReadPixels function. Check that,
 *             framebuffer is filled with red color.
 *
 *             Release objects.
 */
class FunctionalTest : public deqp::TestCase
{
public:
    /* Public member functions */
    FunctionalTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    FunctionalTest(const FunctionalTest &other);
    FunctionalTest &operator=(const FunctionalTest &other);

    void prepareFramebuffer();
    void prepareVertexArrayObject();
    void prepareProgram();
    void prepareTexture();
    void prepareSampler();
    void draw();
    bool checkFramebufferContent();
    void clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
    glw::GLuint m_vao;
    glw::GLuint m_to;
    glw::GLuint m_so;
    glw::GLuint m_po;

    /* Private static variables. */
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
    static const glw::GLchar s_uniform_sampler[];
    static const glw::GLubyte s_texture_data[];
};
/* FunctionalTest class */
} // namespace Samplers

namespace ProgramPipelines
{
/** @class CreationTest
 *
 *  @brief Direct State Access Program Pipeline Objects Creation test cases.
 *
 *  @note Test follows the steps:
 *
 *            Create at least two Program Pipeline Objects names using
 *            GenProgramPipelines function. Check them without binding, using
 *            IsProgramPipeline function. Expect GL_FALSE.
 *
 *            Create at least two Program Pipeline Objects using
 *            CreateProgramPipelines function. Check them without binding, using
 *            IsProgramPipeline function. Expect GL_TRUE.
 *
 *            Release objects.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** @class DefaultsTest
 *
 *  @brief Direct State Access Program Pipeline Objects Default State test.
 *
 *  @note Test follows the steps:
 *
 *            Create Program Pipeline Object with CreateProgramPipelines function.
 *
 *            Verify that default value of ACTIVE_PROGRAM queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Verify that default value of VERTEX_SHADER queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Verify that default value of GEOMETRY_SHADER queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Verify that default value of FRAGMENT_SHADER queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Verify that default value of COMPUTE_SHADER queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Verify that default value of TESS_CONTROL_SHADER queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Verify that default value of TESS_EVALUATION_SHADER queried with
 *            function GetProgramPipelineiv is 0.
 *
 *            Verify that default value of VALIDATE_STATUS queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Verify that default value of info log queried with function
 *            GetProgramPiplineInfoLog is 0.
 *
 *            Verify that default value of INFO_LOG_LENGTH queried with function
 *            GetProgramPipelineiv is 0.
 *
 *            Release object.
 */
class DefaultsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DefaultsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DefaultsTest(const DefaultsTest &other);
    DefaultsTest &operator=(const DefaultsTest &other);

    /* Private member variables */
    glw::GLuint m_program_pipeline_dsa;

    /* Private member functions. */
    void prepare();
    bool testProgramPipelineParameter(glw::GLenum pname, glw::GLint expected_value);
    bool testProgramPipelineInfoLog(glw::GLchar *expected_value);
    void clean();
};
/* DefaultsTest class */

/** @class ErrorsTest
 *
 *  @brief Direct State Access Program Pipeline Negative test.
 *
 *         The test follows steps:
 *
 *             Check that CreateProgramPipelines generates INVALID_VALUE error if
 *             number of program pipeline objects to create is negative.
 */
class ErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ErrorsTest(const ErrorsTest &other);
    ErrorsTest &operator=(const ErrorsTest &other);
};
/* ErrorsTest class */

/** @class FunctionalTest
 *
 *  @brief Direct State Access Program Pipeline Functional test cases.
 *
 *  @note  The test follows steps:
 *
 *             Create framebuffer with renderbuffer with color attachment and 1x1 pixel
 *             size. Clean framebuffer content with black color.
 *
 *             Create and bind empty vertex array object.
 *
 *             Make sure that no GLSL program is being used.
 *
 *             Create two shader programs (with CreateShaderProgramv) - one vertex
 *             shader and one fragment shader. The vertex shader shall output full
 *             screen quad depending on VertexID. The fragment shader shall output red
 *             color.
 *
 *             Create the Program Pipeline Object using CreateProgramPipelines
 *             function. Bind it using BindProgramPipeline. Setup Program Pipeline
 *             with the created shader programs using UseProgramStages.
 *
 *             Draw full screen quad.
 *
 *             Fetch framebuffer content with ReadPixels function. Check that,
 *             framebuffer is filled with red color.
 *
 *             Release objects.
 */
class FunctionalTest : public deqp::TestCase
{
public:
    /* Public member functions */
    FunctionalTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    FunctionalTest(const FunctionalTest &other);
    FunctionalTest &operator=(const FunctionalTest &other);

    void prepareFramebuffer();
    void prepareVertexArrayObject();
    void prepareShaderPrograms();
    void preparePipeline();
    void draw();
    bool checkFramebufferContent();
    void clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
    glw::GLuint m_vao;
    glw::GLuint m_spo_v;
    glw::GLuint m_spo_f;
    glw::GLuint m_ppo;

    /* Private static variables. */
    static const glw::GLchar *s_vertex_shader;
    static const glw::GLchar *s_fragment_shader;
};
/* FunctionalTest class */
} // namespace ProgramPipelines

namespace Queries
{
/** @class CreationTest
 *
 *  @brief Direct State Access Queries Creation test cases.
 *
 *  @note Test follows the steps:
 *
 *            Create at least two Query Objects names using GenQueries function.
 *            Check them without binding, using IsQuery function. Expect GL_FALSE.
 *
 *            Create at least two Query Objects using CreateQueries function. Check
 *            them without binding, using IsQuery function. Expect GL_TRUE.
 *
 *            Release objects.
 *
 *            Repeat test for all of following supported targets:
 *             -  SAMPLES_PASSED,
 *             -  ANY_SAMPLES_PASSED,
 *             -  ANY_SAMPLES_PASSED_CONSERVATIVE,
 *             -  TIME_ELAPSED,
 *             -  TIMESTAMP,
 *             -  PRIMITIVES_GENERATED and
 *             -  TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN.
 *
 *  See Ref. OpenGL 4.5 Core Profile, Section 4.2.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** @class DefaultsTest
 *
 *  @brief Direct State Access Queries Default State test.
 *
 *  @note Test follows the steps:
 *
 *            Create Query Object with CreateQueries function.
 *
 *            Verify that default value of QUERY_RESULT queried with function
 *            GetQueryObjectuiv is 0 or FALSE.
 *
 *            Verify that default value of QUERY_RESULT_AVAILABLE queried with
 *            function GetQueryObjectiv is TRUE.
 *
 *            Release object.
 *
 *            Repeat test for all of following supported targets:
 *             -  SAMPLES_PASSED,
 *             -  ANY_SAMPLES_PASSED,
 *             -  ANY_SAMPLES_PASSED_CONSERVATIVE,
 *             -  TIME_ELAPSED,
 *             -  TIMESTAMP,
 *             -  PRIMITIVES_GENERATED and
 *             -  TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN.
 *
 *  See Ref. OpenGL 4.5 Core Profile, Section 4.2.
 */
class DefaultsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DefaultsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DefaultsTest(const DefaultsTest &other);
    DefaultsTest &operator=(const DefaultsTest &other);

    /* Private member variables */
    glw::GLuint m_query_dsa;

    /* Private member functions. */
    void prepare(const glw::GLenum target);
    bool testQueryParameter(const glw::GLenum pname, const glw::GLuint expected_value, const glw::GLchar *target_name);
    void clean();
};
/* DefaultsTest class */

/** @class ErrorsTest
 *
 *  @brief Direct State Access Queries Negative test.
 *
 *  @note The test follows steps:
 *
 *            Check that CreateQueries generates INVALID_VALUE error if number of
 *            query objects to create is negative.
 *
 *            Check that CreateQueries generates INVALID_ENUM error if target is not
 *            one of accepted values:
 *             -  SAMPLES_PASSED,
 *             -  ANY_SAMPLES_PASSED,
 *             -  ANY_SAMPLES_PASSED_CONSERVATIVE,
 *             -  TIME_ELAPSED,
 *             -  TIMESTAMP,
 *             -  PRIMITIVES_GENERATED or
 *             -  TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN.
 *
 *            Check that GetQueryBufferObjectiv, GetQueryBufferObjectuiv,
 *            GetQueryBufferObjecti64v and GetQueryBufferObjectui64v generate
 *            INVALID_OPERATION error if <id> is not the name of a query object, or
 *            if the query object named by <id> is currently active.
 *
 *            Check that GetQueryBufferObjectiv, GetQueryBufferObjectuiv,
 *            GetQueryBufferObjecti64v and GetQueryBufferObjectui64v generate
 *            INVALID_OPERATION error if <buffer> is not the name of an existing
 *            buffer object.
 *
 *            Check that GetQueryBufferObjectiv, GetQueryBufferObjectuiv,
 *            GetQueryBufferObjecti64v and GetQueryBufferObjectui64v generate
 *            INVALID_ENUM error if <pname> is not QUERY_RESULT,
 *            QUERY_RESULT_AVAILABLE, QUERY_RESULT_NO_WAIT or QUERY_TARGET.
 *
 *            Check that GetQueryBufferObjectiv, GetQueryBufferObjectuiv,
 *            GetQueryBufferObjecti64v and GetQueryBufferObjectui64v generate
 *            INVALID_OPERATION error if the query writes to a buffer object, and the
 *            specified buffer offset would cause data to be written beyond the bounds
 *            of that buffer object.
 *
 *            Check that GetQueryBufferObjectiv, GetQueryBufferObjectuiv,
 *            GetQueryBufferObjecti64v and GetQueryBufferObjectui64v generate
 *            INVALID_VALUE error if <offset> is negative.
 *
 *  See Ref. OpenGL 4.5 Core Profile, Section 4.2.
 */
class ErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ErrorsTest(const ErrorsTest &other);
    ErrorsTest &operator=(const ErrorsTest &other);

    /* Private member functions. */
    bool testNegativeNumberOfObjects();
    bool testInvalidTarget();
    bool testInvalidQueryName();
    bool testInvalidBufferName();
    bool testInvalidParameterName();
    bool testBufferOverflow();
    bool testBufferNegativeOffset();

    bool isTarget(glw::GLenum maybe_target);
    bool isParameterName(glw::GLenum maybe_pname);

    /* Function pointers. */
    typedef void(GLW_APIENTRY *PFNGLGETQUERYBUFFEROBJECT)(glw::GLuint id, glw::GLuint buffer, glw::GLenum pname,
                                                          glw::GLintptr offset);

    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjectiv;
    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjectuiv;
    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjecti64v;
    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjectui64v;

    /* Private static variables. */
    static const glw::GLenum s_targets[];
    static const glw::GLchar *s_target_names[];
    static const glw::GLuint s_targets_count;
};
/* ErrorsTest class */

/** @class FunctionalTest
 *
 *  @brief Direct State Access Queries Functional test cases.
 *
 *  @note The test follows steps:
 *
 *            Create framebuffer with renderbuffer with color attachment and 1x1 pixel
 *            size. Clean framebuffer content with black color.
 *
 *            Create and bind empty vertex array object.
 *
 *            Create buffer object. Bind it to TRANFORM_FEEDBACK_BUFFER binding point.
 *            Bind buffer base to TRANFORM_FEEDBACK_BUFFER binding point with index 0.
 *            Setup data storage of the buffer with size equal to 6 * sizeof(int).
 *
 *            Build GLSL program consisting of vertex and fragment shader stages.
 *            Vertex shader shall output full screen quad depending on VertexID. The
 *            VertexID shall be saved to transform feedback varying. Fragment shader
 *            shall output red color.
 *
 *            Create query objects with CreateQueries function for following targets:
 *             -  SAMPLES_PASSED,
 *             -  PRIMITIVES_GENERATED,
 *             -  TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN,
 *             -  TIME_ELAPSED.
 *
 *            Begin query for every target.
 *
 *            Begin transform feedback for TRIANGLES primitive type.
 *
 *            Draw full screen quad with TRIANGLE_STRIP primitive type.
 *
 *            End transform feedback.
 *
 *            End all queries.
 *
 *            Call Finish function.
 *
 *            Check that framebuffer is filled with red color.
 *
 *            Check that transform feedback buffer contains successive primitive
 *            vertex ids (0, 1, 2,  2, 1, 3).
 *
 *            For every query objects, using GetQueryBufferObjectiv,
 *            GetQueryBufferObjectuiv, GetQueryBufferObjecti64v,
 *            GetQueryBufferObjectui64v functions do following comparisons:
 *
 *                Check that value of parameter QUERY_TARGET is equal to target.
 *
 *                Check that value of parameter QUERY_RESULT_AVAILABLE is TRUE.
 *
 *                Check that value of parameter QUERY_RESULT and QUERY_RESULT_NO_WAIT:
 *                 -  is equal to 1 if target is SAMPLES_PASSED; or
 *                 -  is equal to 2 if target is PRIMITIVES_GENERATED or
 *                    TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN; or
 *                 -  is positive if target is TIME_ELAPSED.
 *
 *            Release objects.
 */
class FunctionalTest : public deqp::TestCase
{
public:
    /* Public member functions */
    FunctionalTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    FunctionalTest(const FunctionalTest &other);
    FunctionalTest &operator=(const FunctionalTest &other);

    /* Function pointers. */
    typedef void(GLW_APIENTRY *PFNGLGETQUERYBUFFEROBJECT)(glw::GLuint id, glw::GLuint buffer, glw::GLenum pname,
                                                          glw::GLintptr offset);

    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjectiv;
    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjectuiv;
    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjecti64v;
    PFNGLGETQUERYBUFFEROBJECT m_pGetQueryBufferObjectui64v;

    /* Private templated functions. */
    template <typename T>
    static bool equal(T, T);

    template <typename T>
    static bool less(T, T);

    template <typename T>
    void GetQueryBufferObject(glw::GLuint id, glw::GLuint buffer, glw::GLenum pname, glw::GLintptr offset);

    template <typename T>
    bool checkQueryBufferObject(glw::GLuint query, glw::GLenum pname, T expected_value, bool (*comparison)(T, T));

    /* Private member functions. */
    void prepareView();
    void prepareVertexArray();
    void prepareBuffers();
    void prepareQueries();
    void prepareProgram();
    void draw();
    bool checkView();
    bool checkXFB();
    void clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
    glw::GLuint m_vao;
    glw::GLuint m_bo_query;
    glw::GLuint m_bo_xfb;
    glw::GLuint *m_qo;
    glw::GLuint m_po;

    /* Private static variables. */
    static const glw::GLenum s_targets[];
    static const glw::GLuint s_targets_count;

    static const glw::GLint s_results[];

    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
    static const glw::GLchar *s_xfb_varying_name;
};
/* FunctionalTest class */

/** @class ReuseTest
 *
 *  @brief Test cases for recycling query handles as different types.
 *
 *  @note Test follows the steps:
 *
 *            Use the EXT_disjoint_timer_query extension to allocate a
 *            GL_TIMESTAMP_EXT type query.
 *
 *            Try to delete and reuse the object as a GL_TIME_ELAPSED
 *            type query.
 */
class ReuseTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ReuseTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ReuseTest(const ReuseTest &other);
    ReuseTest &operator=(const ReuseTest &other);
};
/* ReuseTest class */

} // namespace Queries

namespace Buffers
{
/** @class CreationTest
 *
 *  @brief Direct State Access Buffers Creation test cases.
 *
 *         Test follows the steps:
 *
 *             Create at least two buffer objects using GenBuffers function. Check
 *             them without binding, using IsBuffer function. Expect GL_FALSE.
 *
 *             Create at least two buffer objects using CreateBuffers function. Check
 *             them without binding, using IsBuffer function. Expect GL_TRUE.
 *
 *             Release objects.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** @class DataTest
 *
 *  @brief Direct State Access Buffers Data test cases.
 *
 *         Test follows the steps:
 *
 *             Prepare test case with following steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Create data storage using given function and reference data.
 *
 *             Bind buffer.
 *
 *             Check buffer content using MapBuffer function.
 *
 *             Release objects.
 *
 *             Repeat the test case with function for data creation:
 *              -  NamedBufferData,
 *              -  NamedBufferData and it with NamedBufferSubData,
 *              -  NamedBufferStorage,
 *              -  CopyNamedBufferSubData from auxiliary buffer.
 *
 *             If NamedBufferData function is used then repeat the test case for
 *             usage:
 *              -  STREAM_DRAW,
 *              -  STREAM_READ,
 *              -  STREAM_COPY,
 *              -  STATIC_DRAW,
 *              -  STATIC_READ,
 *              -  STATIC_COPY,
 *              -  DYNAMIC_DRAW,
 *              -  DYNAMIC_READ, and
 *              -  DYNAMIC_COPY.
 *
 *             If NamedBufferStorage function is used then repeat the test case using
 *             flag MAP_READ_BIT and one of following:
 *              -  DYNAMIC_STORAGE_BIT,
 *              -  MAP_WRITE_BIT,
 *              -  MAP_PERSISTENT_BIT,
 *              -  MAP_COHERENT_BIT and
 *              -  CLIENT_STORAGE_BIT.
 */
class DataTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DataTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DataTest(const DataTest &other);
    DataTest &operator=(const DataTest &other);

    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSTORAGE)(glw::GLuint buffer, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data, glw::GLbitfield flags);
    typedef void(GLW_APIENTRY *PFNGLCOPYNAMEDBUFFERSUBDATA)(glw::GLuint readBuffer, glw::GLuint writeBuffer,
                                                            glw::GLintptr readOffset, glw::GLintptr writeOffset,
                                                            glw::GLsizeiptr size);

    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLNAMEDBUFFERSUBDATA m_pNamedBufferSubData;
    PFNGLNAMEDBUFFERSTORAGE m_pNamedBufferStorage;
    PFNGLCOPYNAMEDBUFFERSUBDATA m_pCopyNamedBufferSubData;

    bool TestCase(void (DataTest::*UploadDataFunction)(glw::GLuint, glw::GLenum), glw::GLenum parameter);

    void UploadUsingNamedBufferData(glw::GLuint id, glw::GLenum parameter);
    void UploadUsingNamedBufferSubData(glw::GLuint id, glw::GLenum parameter);
    void UploadUsingNamedBufferStorage(glw::GLuint id, glw::GLenum parameter);
    void UploadUsingCopyNamedBufferSubData(glw::GLuint id, glw::GLenum parameter);

    bool compare(const glw::GLuint *data, const glw::GLuint *reference, const glw::GLsizei count);
    void LogFail(void (DataTest::*UploadDataFunction)(glw::GLuint, glw::GLenum), glw::GLenum parameter,
                 const glw::GLuint *data, const glw::GLuint *reference, const glw::GLsizei count);
    void LogError(void (DataTest::*UploadDataFunction)(glw::GLuint, glw::GLenum), glw::GLenum parameter);

    static const glw::GLuint s_reference[];
    static const glw::GLsizei s_reference_size;
    static const glw::GLsizei s_reference_count;
};
/* DataTest class */

/** @class ClearTest
 *
 *  @brief Direct State Access Buffers Clear test cases.
 *
 *         Test follows the steps:
 *
 *             Prepare test case with following steps:
 *
 *                 Create buffer object using CreateBuffers.
 *
 *                 Create data storage using NamedBufferData without data
 *                 specification.
 *
 *                 Clear buffer content using given function.
 *
 *                 Bind buffer.
 *
 *                 Check buffer content using MapBuffer function.
 *
 *                 Release objects.
 *
 *             Repeat test case for following clear functions:
 *              -  ClearNamedBufferData and
 *              -  ClearNamedBufferSubData.
 *
 *             Repeat test case for following internal formats:
 *              -  GL_R8,
 *              -  GL_R16,
 *              -  GL_R16F,
 *              -  GL_R32F,
 *              -  GL_R8I,
 *              -  GL_R16I,
 *              -  GL_R32I,
 *              -  GL_R8UI,
 *              -  GL_R16UI,
 *              -  GL_R32UI,
 *              -  GL_RG8,
 *              -  GL_RG16,
 *              -  GL_RG16F,
 *              -  GL_RG32F,
 *              -  GL_RG8I,
 *              -  GL_RG16I,
 *              -  GL_RG32I,
 *              -  GL_RG8UI,
 *              -  GL_RG16UI,
 *              -  GL_RG32UI,
 *              -  GL_RGB32F,
 *              -  GL_RGB32I,
 *              -  GL_RGB32UI,
 *              -  GL_RGBA8,
 *              -  GL_RGBA16,
 *              -  GL_RGBA16F,
 *              -  GL_RGBA32F,
 *              -  GL_RGBA8I,
 *              -  GL_RGBA16I,
 *              -  GL_RGBA32I,
 *              -  GL_RGBA8UI,
 *              -  GL_RGBA16UI and
 *              -  GL_RGBA32UI.
 */
class ClearTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ClearTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ClearTest(const ClearTest &other);
    ClearTest &operator=(const ClearTest &other);

    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void(GLW_APIENTRY *PFNGLCLEARNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLenum internalformat,
                                                          glw::GLenum format, glw::GLenum type,
                                                          const glw::GLvoid *data);
    typedef void(GLW_APIENTRY *PFNGLCLEARNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLenum internalformat,
                                                             glw::GLintptr offset, glw::GLsizeiptr size,
                                                             glw::GLenum format, glw::GLenum type,
                                                             const glw::GLvoid *data);

    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLCLEARNAMEDBUFFERDATA m_pClearNamedBufferData;
    PFNGLCLEARNAMEDBUFFERSUBDATA m_pClearNamedBufferSubData;

    template <typename T, bool USE_SUB_DATA>
    bool TestClearNamedBufferData(glw::GLenum internalformat, glw::GLsizei count, glw::GLenum format, glw::GLenum type,
                                  T *data);

    template <bool USE_SUB_DATA>
    void ClearNamedBuffer(glw::GLuint buffer, glw::GLenum internalformat, glw::GLsizei size, glw::GLenum format,
                          glw::GLenum type, glw::GLvoid *data);

    template <typename T>
    bool Compare(const T *data, const T *reference, const glw::GLsizei count);

    template <typename T>
    void LogFail(bool use_sub_data, glw::GLenum internalformat, const T *data, const T *reference,
                 const glw::GLsizei count);

    void LogError(bool use_sub_data, glw::GLenum internalformat);
};
/* ClearTest class */

/** @class MapReadOnlyTest
 *
 *  @brief Direct State Access Buffers Map Read Only test cases.
 *
 *         Test follows the steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Create data storage using NamedBufferData function and reference
 *             data.
 *
 *             Map buffer with MapNamedBuffer function and READ_ONLY access flag.
 *
 *             Compare mapped buffer content with reference data.
 *
 *             Unmap buffer using UnmapNamedBuffer. Test if UnmapNamedBuffer
 *             returned GL_TRUE.
 *
 *             Release buffer.
 */
class MapReadOnlyTest : public deqp::TestCase
{
public:
    /* Public member functions */
    MapReadOnlyTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    MapReadOnlyTest(const MapReadOnlyTest &other);
    MapReadOnlyTest &operator=(const MapReadOnlyTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFER)(glw::GLuint buffer, glw::GLenum access);
    typedef glw::GLboolean(GLW_APIENTRY *PFNGLUNMAPNAMEDBUFFER)(glw::GLuint buffer);

    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLMAPNAMEDBUFFER m_pMapNamedBuffer;
    PFNGLUNMAPNAMEDBUFFER m_pUnmapNamedBuffer;

    static const glw::GLuint s_reference[];      //<! Reference data.
    static const glw::GLsizei s_reference_size;  //<! Reference data size.
    static const glw::GLsizei s_reference_count; //<! Reference data count (number of GLuint elements).
};
/* MapReadOnlyTest class */

/** @class MapReadWriteTest
 *
 *  @brief Direct State Access Buffers Map Read Write test cases.
 *
 *         Test follows the steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Create data storage using NamedBufferData function and reference
 *             data.
 *
 *             Map buffer with MapNamedBuffer function and READ_WRITE access flag.
 *
 *             Compare mapped buffer content with reference.
 *
 *             Write to the mapped buffer inverted reference content.
 *
 *             Unmap buffer.
 *
 *             Map buffer with MapNamedBuffer function and READ_WRITE access flag.
 *
 *             Compare mapped buffer content with inverted reference.
 *
 *             Unmap buffer.
 *
 *             Release buffer.
 */
class MapReadWriteTest : public deqp::TestCase
{
public:
    /* Public member functions */
    MapReadWriteTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    MapReadWriteTest(const MapReadWriteTest &other);
    MapReadWriteTest &operator=(const MapReadWriteTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFER)(glw::GLuint buffer, glw::GLenum access);
    typedef glw::GLboolean(GLW_APIENTRY *PFNGLUNMAPNAMEDBUFFER)(glw::GLuint buffer);

    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLMAPNAMEDBUFFER m_pMapNamedBuffer;
    PFNGLUNMAPNAMEDBUFFER m_pUnmapNamedBuffer;

    static const glw::GLuint s_reference[];      //<! Reference data.
    static const glw::GLsizei s_reference_size;  //<! Reference data size.
    static const glw::GLsizei s_reference_count; //<! Reference data count (number of GLuint elements).
};
/* MapReadWriteTest class */

/** @class MapWriteOnlyTest
 *
 *  @brief Direct State Access Buffers Map Write Only test cases.
 *
 *         Test follows the steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Create data storage using NamedBufferData function.
 *
 *             Map buffer with MapNamedBuffer function and WRITE_ONLY access flag.
 *
 *             Write reference data.
 *
 *             Unmap buffer.
 *
 *             Bind buffer to the binding point.
 *
 *             Map buffer with MapBuffer function and READ_ONLY access flag.
 *
 *             Compare mapped buffer content with reference.
 *
 *             Unmap buffer.
 *
 *             Release buffer.
 */
class MapWriteOnlyTest : public deqp::TestCase
{
public:
    /* Public member functions */
    MapWriteOnlyTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    MapWriteOnlyTest(const MapWriteOnlyTest &other);
    MapWriteOnlyTest &operator=(const MapWriteOnlyTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFER)(glw::GLuint buffer, glw::GLenum access);
    typedef glw::GLboolean(GLW_APIENTRY *PFNGLUNMAPNAMEDBUFFER)(glw::GLuint buffer);

    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLMAPNAMEDBUFFER m_pMapNamedBuffer;
    PFNGLUNMAPNAMEDBUFFER m_pUnmapNamedBuffer;

    static const glw::GLuint s_reference[];      //<! Reference data.
    static const glw::GLsizei s_reference_size;  //<! Reference data size.
    static const glw::GLsizei s_reference_count; //<! Reference data count (number of GLuint elements).
};
/* MapReadOnlyTest class */

/** @class MapRangeReadBitTest
 *
 *  @brief Direct State Access Buffers Range Map Read Bit test cases.
 *
 *         Test follows the steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Create data storage using NamedBufferStorage function, reference
 *             data and MAP_READ_BIT access flag.
 *
 *             Map first half of buffer with MapNamedBufferRange and MAP_READ_BIT
 *             access flag.
 *
 *             Compare mapped buffer content with reference.
 *
 *             Unmap buffer.
 *
 *             Map second half of buffer with MapNamedBufferRange and MAP_READ_BIT
 *             access flag.
 *
 *             Compare mapped buffer content with reference.
 *
 *             Unmap buffer.
 *
 *             Release buffer.
 *
 *             Repeat the test with also MAP_PERSISTENT_BIT flag turned on.
 *
 *             Repeat the test with also MAP_PERSISTENT_BIT and MAP_COHERENT_BIT
 *             flags turned on.
 */
class MapRangeReadBitTest : public deqp::TestCase
{
public:
    /* Public member functions */
    MapRangeReadBitTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    MapRangeReadBitTest(const MapRangeReadBitTest &other);
    MapRangeReadBitTest &operator=(const MapRangeReadBitTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSTORAGE)(glw::GLuint buffer, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data, glw::GLbitfield flags);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFERRANGE)(glw::GLuint buffer, glw::GLintptr offset,
                                                           glw::GLsizeiptr length, glw::GLbitfield access);
    typedef glw::GLboolean(GLW_APIENTRY *PFNGLUNMAPNAMEDBUFFER)(glw::GLuint buffer);

    PFNGLNAMEDBUFFERSTORAGE m_pNamedBufferStorage;
    PFNGLMAPNAMEDBUFFERRANGE m_pMapNamedBufferRange;
    PFNGLUNMAPNAMEDBUFFER m_pUnmapNamedBuffer;

    bool CompareWithReference(glw::GLuint *data, glw::GLintptr offset, glw::GLsizei length);

    static const glw::GLuint s_reference[];      //<! Reference data.
    static const glw::GLsizei s_reference_size;  //<! Reference data size.
    static const glw::GLsizei s_reference_count; //<! Reference data count (number of GLuint elements).
};
/* MapRangeReadBitTest class */

/** @class MapRangeWriteBitTest
 *
 *  @brief Direct State Access Buffers Range Map Read Bit test cases.
 *
 *         Test follows the steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Create data storage using NamedBufferStorage function, reference
 *             data and (MAP_READ_BIT | MAP_WRITE_BIT) access flag.
 *
 *             Map first half of buffer with MapNamedBufferRange and MAP_WRITE_BIT
 *             access flag.
 *
 *             Write reference data.
 *
 *             Unmap buffer.
 *
 *             Map second half of buffer with MapNamedBufferRange and MAP_WRITE_BIT
 *             access flag.
 *
 *             Write reference data.
 *
 *             Unmap buffer.
 *
 *             Bind buffer to the binding point.
 *
 *             Map buffer with MapBuffer function and READ_ONLY access flag.
 *
 *             Compare mapped buffer content with reference.
 *
 *             Unmap buffer.
 *
 *             Release buffer.
 *
 *             Repeat the test with also MAP_INVALIDATE_RANGE_BIT flag turned on.
 *
 *             Repeat the test with also MAP_INVALIDATE_BUFFER_BIT flag turned on with
 *             only the first mapping.
 *
 *             Repeat the test with also MAP_FLUSH_EXPLICIT_BIT flag turned on. Make
 *             sure that all writes are flushed using FlushNamedMappedBufferRange
 *             function.
 *
 *             Repeat the test with also MAP_UNSYNCHRONIZED_BIT flag turned on with
 *             only the second mapping.
 */
class MapRangeWriteBitTest : public deqp::TestCase
{
public:
    /* Public member functions */
    MapRangeWriteBitTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    MapRangeWriteBitTest(const MapRangeWriteBitTest &other);
    MapRangeWriteBitTest &operator=(const MapRangeWriteBitTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSTORAGE)(glw::GLuint buffer, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data, glw::GLbitfield flags);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFERRANGE)(glw::GLuint buffer, glw::GLintptr offset,
                                                           glw::GLsizeiptr length, glw::GLbitfield access);
    typedef glw::GLboolean(GLW_APIENTRY *PFNGLUNMAPNAMEDBUFFER)(glw::GLuint buffer);
    typedef void(GLW_APIENTRY *PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE)(glw::GLuint buffer, glw::GLintptr offset,
                                                                 glw::GLsizeiptr length);

    PFNGLNAMEDBUFFERSTORAGE m_pNamedBufferStorage;
    PFNGLMAPNAMEDBUFFERRANGE m_pMapNamedBufferRange;
    PFNGLUNMAPNAMEDBUFFER m_pUnmapNamedBuffer;
    PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE m_pFlushMappedNamedBufferRange;

    bool CompareWithReference(glw::GLuint buffer, glw::GLbitfield access_flag);

    static const glw::GLuint s_reference[];      //<! Reference data.
    static const glw::GLsizei s_reference_size;  //<! Reference data size.
    static const glw::GLsizei s_reference_count; //<! Reference data count (number of GLuint elements).
};
/* MapRangeWriteBitTest class */

/** @class SubDataQueryTest
 *
 *  @brief Direct State Access GetNamedBufferSubData Query test cases.
 *
 *         Test follows the steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Create data storage using NamedBufferData function and reference data.
 *
 *             Fetch first half of the buffer using GetNamedBufferSubData function.
 *
 *             Fetch second half of the buffer using GetNamedBufferSubData function.
 *
 *             Compare fetched data with reference values.
 *
 *             Release object.
 */
class SubDataQueryTest : public deqp::TestCase
{
public:
    /* Public member functions */
    SubDataQueryTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    SubDataQueryTest(const SubDataQueryTest &other);
    SubDataQueryTest &operator=(const SubDataQueryTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLintptr offset,
                                                           glw::GLsizeiptr size, glw::GLvoid *data);

    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLGETNAMEDBUFFERSUBDATA m_pGetNamedBufferSubData;

    static const glw::GLuint s_reference[];      //<! Reference data.
    static const glw::GLsizei s_reference_size;  //<! Reference data size.
    static const glw::GLsizei s_reference_count; //<! Reference data count (number of GLuint elements).
};
/* SubDataQueryTest class */

/** @class DefaultsTest
 *
 *  @brief Direct State Access Buffer Objects Default Values Test.
 *
 *         Test follows the steps:
 *
 *             Create buffer object using CreateBuffers.
 *
 *             Check that GetNamedBufferParameteriv and GetNamedBufferParameteri64v
 *             function called with parameter name
 *              -  BUFFER_SIZE returns value equal to 0;
 *              -  BUFFER_USAGE returns value equal to STATIC_DRAW;
 *              -  BUFFER_ACCESS returns value equal to READ_WRITE;
 *              -  BUFFER_ACCESS_FLAGS returns value equal to 0;
 *              -  BUFFER_IMMUTABLE_STORAGE returns value equal to FALSE;
 *              -  BUFFER_MAPPED returns value equal to FALSE;
 *              -  BUFFER_MAP_OFFSET returns value equal to 0;
 *              -  BUFFER_MAP_LENGTH returns value equal to 0;
 *              -  BUFFER_STORAGE_FLAGS returns value equal to 0.
 *
 *            Check that GetNamedBufferPointerv function called with parameter name
 *            BUFFER_MAP_POINTER returns value equal to NULL;
 */
class DefaultsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DefaultsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DefaultsTest(const DefaultsTest &other);
    DefaultsTest &operator=(const DefaultsTest &other);

    bool CheckParameterError(const glw::GLchar *pname_string, const glw::GLchar *function_string);

    template <typename T>
    bool CheckValue(const T value, const T reference_value, const glw::GLchar *pname_string,
                    const glw::GLchar *function_string);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPARAMETERI64V)(glw::GLuint buffer, glw::GLenum pname,
                                                                 glw::GLint64 *data);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPARAMETERIV)(glw::GLuint buffer, glw::GLenum pname, glw::GLint *data);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPOINTERV)(glw::GLuint buffer, glw::GLenum pname,
                                                            glw::GLvoid **params);

    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLGETNAMEDBUFFERPARAMETERI64V m_pGetNamedBufferParameteri64v;
    PFNGLGETNAMEDBUFFERPARAMETERIV m_pGetNamedBufferParameteriv;
    PFNGLGETNAMEDBUFFERPOINTERV m_pGetNamedBufferPointerv;
};
/* DefaultsTest class */

/** @class ErrorsTest
 *
 *  @brief Direct State Access Buffer Objects Errors Test.
 *
 *         Test follows the steps:
 *
 *                     Check that INVALID_VALUE is generated by CreateBuffers if n is negative.
 *
 *
 *                     Check that INVALID_OPERATION is generated by NamedBufferStorage if
 *                     buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_VALUE is generated by NamedBufferStorage if size is
 *                     less than or equal to zero.
 *
 *                     Check that INVALID_VALUE is generated by NamedBufferStorage if flags has
 *                     any bits set other than DYNAMIC_STORAGE_BIT, MAP_READ_BIT,
 *                     MAP_WRITE_BIT, MAP_PERSISTENT_BIT, MAP_COHERENT_BIT or
 *                     CLIENT_STORAGE_BIT.
 *
 *                     Check that INVALID_VALUE error is generated by NamedBufferStorage if
 *                     flags contains MAP_PERSISTENT_BIT but does not contain at least one of
 *                     MAP_READ_BIT or MAP_WRITE_BIT.
 *
 *                     Check that INVALID_VALUE is generated by NamedBufferStorage if flags
 *                     contains MAP_COHERENT_BIT, but does not also contain MAP_PERSISTENT_BIT.
 *
 *                     Check that OUT_OF_MEMORY is generated if the GL is unable to create a
 *                     data store with the specified size. Do not set result, if out of memory
 *                     situation was impossible to generate or unable to verify.
 *
 *
 *                     Check that INVALID_OPERATION is generated by NamedBufferData if buffer
 *                     is not the name of an existing buffer object.
 *
 *                     Check that INVALID_ENUM is generated by NamedBufferData if usage is not
 *                     STREAM_DRAW, STREAM_READ, STREAM_COPY, STATIC_DRAW, STATIC_READ,
 *                     STATIC_COPY, DYNAMIC_DRAW, DYNAMIC_READ or DYNAMIC_COPY.
 *
 *                     Check that INVALID_VALUE is generated by NamedBufferData if size is
 *                     negative.
 *
 *                     Check that INVALID_OPERATION is generated by NamedBufferData if the
 *                     BUFFER_IMMUTABLE_STORAGE flag of the buffer object is TRUE.
 *
 *                     Check that OUT_OF_MEMORY is generated if the GL is unable to create a
 *                     data store with the specified size. Do not set result, if out of memory
 *                     situation was impossible to generate or unable to verify.
 *
 *
 *                     Check that INVALID_OPERATION is generated by NamedBufferSubData if
 *                     buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_VALUE is generated by NamedBufferSubData if offset or
 *                     size is negative, or if offset+size is greater than the value of
 *                     BUFFER_SIZE for the specified buffer object.
 *
 *                     Check that INVALID_OPERATION is generated by NamedBufferSubData if any
 *                     part of the specified range of the buffer object is mapped with
 *                     MapBufferRange or MapBuffer, unless it was mapped with the
 *                     MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags.
 *
 *                     Check that INVALID_OPERATION is generated by NamedBufferSubData if the
 *                     value of the BUFFER_IMMUTABLE_STORAGE flag of the buffer object is TRUE
 *                     and the value of BUFFER_STORAGE_FLAGS for the buffer object does not
 *                     have the DYNAMIC_STORAGE_BIT bit set.
 *
 *
 *                     Check that INVALID_OPERATION is generated by ClearNamedBufferData if
 *                     buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_ENUM is generated by ClearNamedBufferData if
 *                     internal format is not one of the valid sized internal formats listed in
 *                     the table above.
 *
 *                     Check that INVALID_OPERATION is generated by ClearNamedBufferData if
 *                     any part of the specified range of the buffer object is mapped with
 *                     MapBufferRange or MapBuffer, unless it was mapped with the
 *                     MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags.
 *
 *                     Check that INVALID_VALUE is generated by ClearNamedBufferData if
 *                     format is not a valid format, or type is not a valid type.
 *
 *
 *                     Check that INVALID_OPERATION is generated by ClearNamedBufferSubData
 *                     if buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_ENUM is generated by ClearNamedBufferSubData if
 *                     internal format is not one of the valid sized internal formats listed in
 *                     the table above.
 *
 *                     Check that INVALID_VALUE is generated by ClearNamedBufferSubData if
 *                     offset or range are not multiples of the number of basic machine units
 *                     per-element for the internal format specified by internal format. This
 *                     value may be computed by multiplying the number of components for
 *                     internal format from the table by the size of the base type from the
 *                     specification table.
 *
 *                     Check that INVALID_VALUE is generated by ClearNamedBufferSubData if
 *                     offset or size is negative, or if offset+size is greater than the value
 *                     of BUFFER_SIZE for the buffer object.
 *
 *                     Check that INVALID_OPERATION is generated by ClearNamedBufferSubData
 *                     if any part of the specified range of the buffer object is mapped with
 *                     MapBufferRange or MapBuffer, unless it was mapped with the
 *                     MAP_PERSISTENT_BIT bit set in the MapBufferRange access flags.
 *
 *                     Check that INVALID_VALUE is generated by ClearNamedBufferSubData if
 *                     format is not a valid format, or type is not a valid type.
 *
 *
 *                     Check that INVALID_OPERATION is generated by CopyNamedBufferSubData if
 *                     readBuffer or writeBuffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_VALUE is generated by CopyNamedBufferSubData if any of
 *                     readOffset, writeOffset or size is negative, if readOffset+size is
 *                     greater than the size of the source buffer object (its value of
 *                     BUFFER_SIZE), or if writeOffset+size is greater than the size of the
 *                     destination buffer object.
 *
 *                     Check that INVALID_VALUE is generated by CopyNamedBufferSubData if the
 *                     source and destination are the same buffer object, and the ranges
 *                     [readOffset,readOffset+size) and [writeOffset,writeOffset+size) overlap.
 *
 *                     Check that INVALID_OPERATION is generated by CopyNamedBufferSubData if
 *                     either the source or destination buffer object is mapped with
 *                     MapBufferRange or MapBuffer, unless they were mapped with the
 *                     MAP_PERSISTENT bit set in the MapBufferRange access flags.
 *
 *
 *                     Check that INVALID_OPERATION is generated by MapNamedBuffer if buffer is
 *                     not the name of an existing buffer object.
 *
 *                     Check that INVALID_ENUM is generated by MapNamedBuffer if access is not
 *                     READ_ONLY, WRITE_ONLY, or READ_WRITE.
 *
 *                     Check that INVALID_OPERATION is generated by MapNamedBuffer if the
 *                     buffer object is in a mapped state.
 *
 *
 *                     Check that INVALID_OPERATION is generated by MapNamedBufferRange if
 *                     buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_VALUE is generated by MapNamedBufferRange if offset
 *                     or length is negative, if offset+length is greater than the value of
 *                     BUFFER_SIZE for the buffer object, or if access has any bits set other
 *                     than those defined above.
 *
 *                     Check that INVALID_OPERATION is generated by MapNamedBufferRange for any
 *                     of the following conditions:
 *                      -  length is zero.
 *                      -  The buffer object is already in a mapped state.
 *                      -  Neither MAP_READ_BIT nor MAP_WRITE_BIT is set.
 *                      -  MAP_READ_BIT is set and any of MAP_INVALIDATE_RANGE_BIT,
 *                         MAP_INVALIDATE_BUFFER_BIT or MAP_UNSYNCHRONIZED_BIT is set.
 *                      -  MAP_FLUSH_EXPLICIT_BIT is set and MAP_WRITE_BIT is not set.
 *                      -  Any of MAP_READ_BIT, MAP_WRITE_BIT, MAP_PERSISTENT_BIT, or
 *                         MAP_COHERENT_BIT are set, but the same bit is not included in the
 *                         buffer's storage flags.
 *
 *
 *                     Check that INVALID_OPERATION is generated by UnmapNamedBuffer if buffer
 *                     is not the name of an existing buffer object.
 *
 *                     Check that INVALID_OPERATION is generated by UnmapNamedBuffer if the
 *                     buffer object is not in a mapped state.
 *
 *
 *                     Check that INVALID_OPERATION is generated by FlushMappedNamedBufferRange
 *                     if buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_VALUE is generated by FlushMappedNamedBufferRange if
 *                     offset or length is negative, or if offset + length exceeds the size of
 *                     the mapping.
 *
 *                     Check that INVALID_OPERATION is generated by FlushMappedNamedBufferRange
 *                     if the buffer object is not mapped, or is mapped without the
 *                     MAP_FLUSH_EXPLICIT_BIT flag.
 *
 *
 *                     Check that INVALID_OPERATION is generated by GetNamedBufferParameter* if
 *                     buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_ENUM is generated by GetNamedBufferParameter* if
 *                     pname is not one of the buffer object parameter names: BUFFER_ACCESS,
 *                     BUFFER_ACCESS_FLAGS, BUFFER_IMMUTABLE_STORAGE, BUFFER_MAPPED,
 *                     BUFFER_MAP_LENGTH, BUFFER_MAP_OFFSET, BUFFER_SIZE, BUFFER_STORAGE_FLAGS,
 *                     BUFFER_USAGE.
 *
 *
 *                     Check that INVALID_OPERATION is generated by GetNamedBufferPointerv
 *                     if buffer is not the name of an existing buffer object.
 *
 *
 *                     Check that INVALID_OPERATION is generated by GetNamedBufferSubData if
 *                     buffer is not the name of an existing buffer object.
 *
 *                     Check that INVALID_VALUE is generated by GetNamedBufferSubData if offset
 *                     or size is negative, or if offset+size is greater than the value of
 *                     BUFFER_SIZE for the buffer object.
 *
 *                     Check that INVALID_OPERATION is generated by GetNamedBufferSubData if
 *                     the buffer object is mapped with MapBufferRange or MapBuffer, unless it
 *                     was mapped with the MAP_PERSISTENT_BIT bit set in the MapBufferRange
 *                     access flags.
 */
class ErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ErrorsTest(const ErrorsTest &other);
    ErrorsTest &operator=(const ErrorsTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLCLEARNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLenum internalformat,
                                                          glw::GLenum format, glw::GLenum type,
                                                          const glw::GLvoid *data);
    typedef void(GLW_APIENTRY *PFNGLCLEARNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLenum internalformat,
                                                             glw::GLintptr offset, glw::GLsizeiptr size,
                                                             glw::GLenum format, glw::GLenum type,
                                                             const glw::GLvoid *data);
    typedef void(GLW_APIENTRY *PFNGLCOPYNAMEDBUFFERSUBDATA)(glw::GLuint readBuffer, glw::GLuint writeBuffer,
                                                            glw::GLintptr readOffset, glw::GLintptr writeOffset,
                                                            glw::GLsizeiptr size);
    typedef void(GLW_APIENTRY *PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE)(glw::GLuint buffer, glw::GLintptr offset,
                                                                 glw::GLsizeiptr length);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPARAMETERI64V)(glw::GLuint buffer, glw::GLenum pname,
                                                                 glw::GLint64 *data);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPARAMETERIV)(glw::GLuint buffer, glw::GLenum pname, glw::GLint *data);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPOINTERV)(glw::GLuint buffer, glw::GLenum pname,
                                                            glw::GLvoid **params);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLintptr offset,
                                                           glw::GLsizeiptr size, glw::GLvoid *data);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFER)(glw::GLuint buffer, glw::GLenum access);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFERRANGE)(glw::GLuint buffer, glw::GLintptr offset,
                                                           glw::GLsizeiptr length, glw::GLbitfield access);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSTORAGE)(glw::GLuint buffer, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data, glw::GLbitfield flags);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data);
    typedef glw::GLboolean(GLW_APIENTRY *PFNGLUNMAPNAMEDBUFFER)(glw::GLuint buffer);

    PFNGLCLEARNAMEDBUFFERDATA m_pClearNamedBufferData;
    PFNGLCLEARNAMEDBUFFERSUBDATA m_pClearNamedBufferSubData;
    PFNGLCOPYNAMEDBUFFERSUBDATA m_pCopyNamedBufferSubData;
    PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE m_pFlushMappedNamedBufferRange;
    PFNGLGETNAMEDBUFFERPARAMETERI64V m_pGetNamedBufferParameteri64v;
    PFNGLGETNAMEDBUFFERPARAMETERIV m_pGetNamedBufferParameteriv;
    PFNGLGETNAMEDBUFFERPOINTERV m_pGetNamedBufferPointerv;
    PFNGLGETNAMEDBUFFERSUBDATA m_pGetNamedBufferSubData;
    PFNGLMAPNAMEDBUFFER m_pMapNamedBuffer;
    PFNGLMAPNAMEDBUFFERRANGE m_pMapNamedBufferRange;
    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLNAMEDBUFFERSTORAGE m_pNamedBufferStorage;
    PFNGLNAMEDBUFFERSUBDATA m_pNamedBufferSubData;
    PFNGLUNMAPNAMEDBUFFER m_pUnmapNamedBuffer;

    /* Private member functions */
    bool TestErrorsOfClearNamedBufferData();
    bool TestErrorsOfClearNamedBufferSubData();
    bool TestErrorsOfCopyNamedBufferSubData();
    bool TestErrorsOfCreateBuffers();
    bool TestErrorsOfFlushMappedNamedBufferRange();
    bool TestErrorsOfGetNamedBufferParameter();
    bool TestErrorsOfGetNamedBufferPointerv();
    bool TestErrorsOfGetNamedBufferSubData();
    bool TestErrorsOfMapNamedBuffer();
    bool TestErrorsOfMapNamedBufferRange();
    bool TestErrorsOfNamedBufferData();
    bool TestErrorsOfNamedBufferStorage();
    bool TestErrorsOfNamedBufferSubData();
    bool TestErrorsOfUnmapNamedBuffer();

    bool ErrorCheckAndLog(const glw::GLchar *function_name, const glw::GLenum expected_error,
                          const glw::GLchar *when_shall_be_generated);
};
/* ErrorsTest class */

/** @class FunctionalTest
 *
 *  @brief Direct State Access Buffer Objects Functional Test.
 *
 *         This test verifies basic usage in rendering pipeline of the tested
 *         functions:
 *         -  ClearNamedBufferData,
 *         -  ClearNamedBufferSubData,
 *         -  CopyNamedBufferSubData,
 *         -  FlushMappedNamedBufferRange,
 *         -  GetNamedBufferParameteri64v,
 *         -  GetNamedBufferParameteriv,
 *         -  GetNamedBufferPointerv,
 *         -  GetNamedBufferSubData,
 *         -  MapNamedBuffer,
 *         -  MapNamedBufferRange,
 *         -  NamedBufferData,
 *         -  NamedBufferStorage,
 *         -  NamedBufferSubData and
 *         -  UnmapNamedBuffer.
 *
 *         Test follows the steps:
 *
 *             Prepare program with vertex shader and fragment shader. Fragment shader
 *             shall be pass-trough. Vertex shader shall have one integer input
 *             variable. Vertex shader shall output (to transform feedback) square of
 *             input variable. gl_Position shall be set up to vec4(0.0, 0.0, 0.0, 1.0).
 *             Build and use the program.
 *
 *             Create and bind empty vertex array object.
 *
 *             Prepare one buffer using CreateBuffers and NamedBufferStorage with size
 *             of 6 integers and passing pointer to data {1, 2, 3, 4, 5, 5} and dynamic
 *             storage flag set on. Clear (with 0) the first element with
 *             ClearNamedBufferSubData. Set second data element to 1 using
 *             NamedBufferSubData. Set third data element to 2 using MapNamedBuffer
 *             and UnmapNamedBuffer. Bind it to ARRAY_BUFFER binding point. Copy forth
 *             element into fifth element using CopyNamedBufferSubData. Set fourth data
 *             element using MapNamedBufferRange and FlushMappedNamedBuffer to 3.
 *             During mapping check that GetNamedBufferPointerv called with
 *             BUFFER_MAP_POINTER returns proper pointer. Unmap it using
 *             UnmapNamedBuffer function. Setup buffer as an input attribute to GLSL
 *             program. Consequently, the resulting buffer shall be {0, 1, 2, 3, 4, 5}.
 *
 *             Prepare one buffer using GenBuffers. Bind it to transform feedback.
 *             Allocate it's storage using NamedBufferData with size of 7 integers and
 *             passing pointer to data {0, 0, 0, 0, 0, 0, 36}. Set up this buffer as
 *             transform feedback output.
 *
 *             Begin transform feedback.
 *
 *             Draw six indices using points.
 *
 *             End transform feedback.
 *
 *             Query array buffer's parameter BUFFER_IMMUTABLE_STORAGE with
 *             GetNamedBufferParameteriv and compare with previous setup.
 *
 *             Query transform feedback buffer size with GetNamedBufferParameteri64v
 *             and compare with previous setup.
 *
 *             Fetch transform feedback buffer content using GetNamedBufferSubData and
 *             queried size.
 *
 *             Check that fetched data is equal to {0, 1, 4, 9, 16, 25, 36}.
 *
 *             If any check fails, test shall fail.
 *
 *             If any of the tested functions generates error, test shall fail.
 */
class FunctionalTest : public deqp::TestCase
{
public:
    /* Public member functions */
    FunctionalTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    FunctionalTest(const FunctionalTest &other);
    FunctionalTest &operator=(const FunctionalTest &other);

    /* API entry points. */
    typedef void(GLW_APIENTRY *PFNGLCLEARNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLenum internalformat,
                                                          glw::GLenum format, glw::GLenum type,
                                                          const glw::GLvoid *data);
    typedef void(GLW_APIENTRY *PFNGLCLEARNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLenum internalformat,
                                                             glw::GLintptr offset, glw::GLsizeiptr size,
                                                             glw::GLenum format, glw::GLenum type,
                                                             const glw::GLvoid *data);
    typedef void(GLW_APIENTRY *PFNGLCOPYNAMEDBUFFERSUBDATA)(glw::GLuint readBuffer, glw::GLuint writeBuffer,
                                                            glw::GLintptr readOffset, glw::GLintptr writeOffset,
                                                            glw::GLsizeiptr size);
    typedef void(GLW_APIENTRY *PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE)(glw::GLuint buffer, glw::GLintptr offset,
                                                                 glw::GLsizeiptr length);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPARAMETERI64V)(glw::GLuint buffer, glw::GLenum pname,
                                                                 glw::GLint64 *data);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPARAMETERIV)(glw::GLuint buffer, glw::GLenum pname, glw::GLint *data);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERPOINTERV)(glw::GLuint buffer, glw::GLenum pname,
                                                            glw::GLvoid **params);
    typedef void(GLW_APIENTRY *PFNGLGETNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLintptr offset,
                                                           glw::GLsizeiptr size, glw::GLvoid *data);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFER)(glw::GLuint buffer, glw::GLenum access);
    typedef void *(GLW_APIENTRY *PFNGLMAPNAMEDBUFFERRANGE)(glw::GLuint buffer, glw::GLintptr offset,
                                                           glw::GLsizeiptr length, glw::GLbitfield access);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERDATA)(glw::GLuint buffer, glw::GLsizeiptr size, const glw::GLvoid *data,
                                                     glw::GLenum usage);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSTORAGE)(glw::GLuint buffer, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data, glw::GLbitfield flags);
    typedef void(GLW_APIENTRY *PFNGLNAMEDBUFFERSUBDATA)(glw::GLuint buffer, glw::GLintptr offset, glw::GLsizeiptr size,
                                                        const glw::GLvoid *data);
    typedef glw::GLboolean(GLW_APIENTRY *PFNGLUNMAPNAMEDBUFFER)(glw::GLuint buffer);

    PFNGLCLEARNAMEDBUFFERDATA m_pClearNamedBufferData;
    PFNGLCLEARNAMEDBUFFERSUBDATA m_pClearNamedBufferSubData;
    PFNGLCOPYNAMEDBUFFERSUBDATA m_pCopyNamedBufferSubData;
    PFNGLFLUSHMAPPEDNAMEDBUFFERRANGE m_pFlushMappedNamedBufferRange;
    PFNGLGETNAMEDBUFFERPARAMETERI64V m_pGetNamedBufferParameteri64v;
    PFNGLGETNAMEDBUFFERPARAMETERIV m_pGetNamedBufferParameteriv;
    PFNGLGETNAMEDBUFFERPOINTERV m_pGetNamedBufferPointerv;
    PFNGLGETNAMEDBUFFERSUBDATA m_pGetNamedBufferSubData;
    PFNGLMAPNAMEDBUFFER m_pMapNamedBuffer;
    PFNGLMAPNAMEDBUFFERRANGE m_pMapNamedBufferRange;
    PFNGLNAMEDBUFFERDATA m_pNamedBufferData;
    PFNGLNAMEDBUFFERSTORAGE m_pNamedBufferStorage;
    PFNGLNAMEDBUFFERSUBDATA m_pNamedBufferSubData;
    PFNGLUNMAPNAMEDBUFFER m_pUnmapNamedBuffer;

    /* Private member variables. */
    glw::GLuint m_po;
    glw::GLuint m_vao;
    glw::GLuint m_bo_in;
    glw::GLuint m_bo_out;
    glw::GLint m_attrib_location;

    /* Private static variables. */
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
    static const glw::GLchar s_vertex_shader_input_name[];
    static const glw::GLchar *s_vertex_shader_output_name;

    static const glw::GLint s_initial_data_a[];
    static const glw::GLint s_initial_data_b[];
    static const glw::GLint s_expected_data[];

    /* Private member functions */
    void BuildProgram();
    void PrepareVertexArrayObject();
    bool PrepareInputBuffer();
    bool PrepareOutputBuffer();
    void Draw();
    bool CheckArrayBufferImmutableFlag();
    bool CheckTransformFeedbackBufferSize();
    bool CheckTransformFeedbackResult();
    void Cleanup();
};
/* FunctionalTest class */
} // namespace Buffers

namespace Framebuffers
{
/** Framebuffer Creation
 *
 *      Create at least two framebuffer objects using GenFramebuffers function.
 *      Check them without binding, using IsFramebuffer function. Expect FALSE.
 *
 *      Create at least two framebuffer objects using CreateFramebuffers
 *      function. Check them without binding, using IsFramebuffer function.
 *      Expect TRUE.
 *
 *      Release objects.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** Framebuffer Renderbuffer Attachment
 *
 *      Create renderbuffer using GenRenderbuffers function. Bind it. Prepare
 *      its storage using RenderbufferStorage. Unbind it.
 *
 *      Create framebuffer using CreateFramebuffers. Setup renderbuffer storage.
 *      Attach the renderbuffer to the framebuffer using
 *      NamedFramebufferRenderbuffer function.
 *
 *      Bind framebuffer and check its status using CheckFramebufferStatus
 *      function call.
 *
 *      Clear the framebuffer's content with the reference value. Fetch the
 *      framebuffer's content using ReadPixels and compare it with reference
 *      values.
 *
 *      Repeat the test for following attachment types:
 *       -  COLOR_ATTACHMENTi for i from 0 to value of MAX_COLOR_ATTACHMENTS
 *          minus one,
 *       -  DEPTH_ATTACHMENT,
 *       -  STENCIL_ATTACHMENT and
 *       -  DEPTH_STENCIL_ATTACHMENT.
 */
class RenderbufferAttachmentTest : public deqp::TestCase
{
public:
    /* Public member functions */
    RenderbufferAttachmentTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    RenderbufferAttachmentTest(const RenderbufferAttachmentTest &other);
    RenderbufferAttachmentTest &operator=(const RenderbufferAttachmentTest &other);

    bool Test(glw::GLenum attachment, glw::GLenum internalformat);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
};
/* RenderbufferAttachmentTest class */

/** Named Framebuffer Texture Attachment
 *
 *      Create texture using CreateTexture function. Prepare its storage using
 *      TexStorage*D*.
 *
 *      Create framebuffer using CreateFramebuffers. Attach the texture to
 *      the framebuffer using NamedFramebufferTexture function. Repeat
 *      attachment for all texture levels.
 *
 *      Bind framebuffer and check its status using CheckFramebufferStatus
 *      function call.
 *
 *      Clear the framebuffer's content with the reference value. Fetch the
 *      framebuffer's content using ReadPixels and compare it with reference
 *      values.
 *
 *      Repeat the test for following attachment types:
 *       -  COLOR_ATTACHMENTi for i from 0 to value of MAX_COLOR_ATTACHMENTS
 *          minus one,
 *       -  DEPTH_ATTACHMENT,
 *       -  STENCIL_ATTACHMENT and
 *       -  DEPTH_STENCIL_ATTACHMENT.
 *
 *      Repeat the test for following texture targets:
 *       -  TEXTURE_RECTANGLE,
 *       -  TEXTURE_2D,
 *       -  TEXTURE_2D_MULTISAMPLE,
 *       -  TEXTURE_CUBE_MAP.
 *
 *      Repeat the test with each possible texture level, that is:
 *       -  0 for TEXTURE_RECTANGLE and TEXTURE_2D_MULTISAMPLE targets;
 *       -  from zero to value one less than base 2 logarithm of the value of
 *          MAX_3D_TEXTURE_SIZE for TEXTURE_2D target
 *       -  from zero to value one less than base 2 logarithm of the value of
 *          MAX_CUBE_MAP_TEXTURE_SIZE for TEXTURE_CUBE_MAP target.
 */
class TextureAttachmentTest : public deqp::TestCase
{
public:
    /* Public member functions */
    TextureAttachmentTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    TextureAttachmentTest(const TextureAttachmentTest &other);
    TextureAttachmentTest &operator=(const TextureAttachmentTest &other);

    bool Test(glw::GLenum attachment, bool is_color_attachment, glw::GLenum texture_target, glw::GLenum internalformat,
              glw::GLuint levels);
    bool SubTestAttachmentError(glw::GLenum attachment, glw::GLenum texture_target, glw::GLuint level,
                                glw::GLuint levels);
    bool SubTestStatus(glw::GLenum attachment, glw::GLenum texture_target, glw::GLuint level, glw::GLuint levels);
    bool SubTestContent(glw::GLenum attachment, glw::GLenum texture_target, glw::GLenum internalformat,
                        glw::GLuint level, glw::GLuint levels);
    glw::GLuint MaxTextureLevels(glw::GLenum texture_target);
    void Clear();
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_to;

    /* Static private variables. */
    static const glw::GLenum s_targets[];
    static const glw::GLuint s_targets_count;

    static const glw::GLfloat s_reference_color[4];
    static const glw::GLint s_reference_color_integer[4];
    static const glw::GLfloat s_reference_depth;
    static const glw::GLint s_reference_stencil;
};
/* TextureAttachmentTest class */

/** Named Framebuffer Texture Layer Attachment
 *
 *      Create texture using CreateTexture function. Prepare its storage using
 *      TexStorage*D*.
 *
 *      Create framebuffer using CreateFramebuffers. Attach the texture to the
 *      framebuffer using NamedFramebufferTextureLayer function.
 *
 *      Bind framebuffer and check its status using CheckFramebufferStatus
 *      function call.
 *
 *      For non multisample target, clean the framebuffer's content with the
 *      reference value. Fetch one pixel from framebuffer's content using
 *      ReadPixels and compare it with reference values.
 *
 *      Repeat the test for following attachment types:
 *       -  COLOR_ATTACHMENTi for i from 0 to value of MAX_COLOR_ATTACHMENTS
 *          minus one,
 *       -  DEPTH_ATTACHMENT,
 *       -  STENCIL_ATTACHMENT and
 *       -  DEPTH_STENCIL_ATTACHMENT.
 *
 *      Repeat the test for following texture targets:
 *       -  TEXTURE_2D_MULTISAMPLE_ARRAY,
 *       -  TEXTURE_2D_ARRAY,
 *       -  TEXTURE_CUBE_MAP_ARRAY,
 *       -  TEXTURE_3D.
 *
 *      Repeat the test for texture levels from zero to value one less than base
 *      2 logarithm of the value of MAX_3D_TEXTURE_SIZE.
 *
 *      Repeat with texture which has number of layers:
 *       -  1,
 *       -  256,
 *       -  value of MAX_CUBE_MAP_TEXTURE_SIZE for TEXTURE_CUBE_ARRAY or value
 *          of MAX_3D_TEXTURE_SIZE.
 *      Test only limited set of the layers of the above textures to reduce time
 *      complexity of the test.
 */
class TextureLayerAttachmentTest : public deqp::TestCase
{
public:
    /* Public member functions */
    TextureLayerAttachmentTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    TextureLayerAttachmentTest(const TextureLayerAttachmentTest &other);
    TextureLayerAttachmentTest &operator=(const TextureLayerAttachmentTest &other);

    bool Test(glw::GLenum attachment, bool is_color_attachment, glw::GLenum texture_target, glw::GLenum internalformat,
              glw::GLuint levels, glw::GLint layers);
    bool SubTestAttachmentError(glw::GLenum attachment, glw::GLenum texture_target, glw::GLuint level, glw::GLint layer,
                                glw::GLuint levels, glw::GLint layers);
    bool SubTestStatus(glw::GLenum attachment, glw::GLenum texture_target, glw::GLuint level, glw::GLint layer,
                       glw::GLuint levels, glw::GLint layers);
    bool SubTestContent(glw::GLenum attachment, glw::GLenum texture_target, glw::GLenum internalformat,
                        glw::GLuint level, glw::GLint layer, glw::GLuint levels, glw::GLint layers);
    void Clear();
    glw::GLuint MaxTextureLevels(glw::GLenum texture_target);
    glw::GLuint MaxTextureLayers(glw::GLenum texture_target);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_to;

    /* Static private variables. */
    static const glw::GLenum s_targets[];
    static const glw::GLuint s_targets_count;

    static const glw::GLfloat s_reference_color[4];
    static const glw::GLint s_reference_color_integer[4];
    static const glw::GLfloat s_reference_depth;
    static const glw::GLint s_reference_stencil;
};
/* TextureLayerAttachmentTest class */

/** Named Framebuffer Draw Read Buffer
 *
 *      Create named framebuffer with maximum number of color attachments (use
 *      named renderbuffer storage).
 *
 *      For each color attachment use NamedFramebufferDrawBuffer to set up it as
 *      a draw buffer. Clear it with unique color.
 *
 *      For each color attachment use NamedFramebufferReadBuffer to set up it as
 *      a read buffer. Fetch the pixel data and compare that it contains unique
 *      color with the attachment was cleared
 *
 *      Check that NamedFramebufferDrawBuffer and NamedFramebufferReadBuffer
 *      accept GL_NONE as mode without error.
 *
 *      Release all objects.
 */
class DrawReadBufferTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DrawReadBufferTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DrawReadBufferTest(const DrawReadBufferTest &other);
    DrawReadBufferTest &operator=(const DrawReadBufferTest &other);
};
/* DrawReadBufferTest class */

/** Named Framebuffer Draw Buffers
 *
 *      Create named framebuffer with maximum number of color attachments (use
 *      named renderbuffer storage).
 *
 *      Set up all attachments as a draw buffer using the function
 *      NamedFramebufferDrawBuffers. Then clear them at once with unique color.
 *
 *      For each color attachment fetch pixel data and compare that contain
 *      the same unique color.
 *
 *      Release all objects.
 */
class DrawBuffersTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DrawBuffersTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DrawBuffersTest(const DrawBuffersTest &other);
    DrawBuffersTest &operator=(const DrawBuffersTest &other);

    /* Private static constants. */
    static const glw::GLfloat s_rgba[4];
};
/* DrawReadBuffersTest class */

/** Invalidate Named Framebuffer Data
 *
 *      For default framebuffer try to invalidate each of COLOR, DEPTH, and
 *      STENCIL attachments. Expect no error.
 *
 *      For default framebuffer try to invalidate all (COLOR, DEPTH, and
 *      STENCIL) attachments. Expect no error.
 *
 *      Create named framebuffer with maximum number of color attachments (use
 *      named renderbuffer storage), depth attachment and stencil attachment.
 *
 *      Clear all attachments.
 *
 *      Try to invalidate content of all attachments using
 *      InvalidateNamedFramebufferData. Expect no error.
 *
 *      Try to invalidate content of each attachment using
 *      InvalidateNamedFramebufferData. Expect no error.
 *
 *      Release all objects.
 */
class InvalidateDataTest : public deqp::TestCase
{
public:
    /* Public member functions */
    InvalidateDataTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    InvalidateDataTest(const InvalidateDataTest &other);
    InvalidateDataTest &operator=(const InvalidateDataTest &other);

    bool CheckErrorAndLog(const glw::GLenum attachment);
    bool CheckErrorAndLog(const glw::GLenum attachments[], const glw::GLuint count);
};
/* InvalidateDataTest class */

/** Invalidate Named Framebuffer SubData
 *
 *      For default framebuffer try to invalidate part of each of COLOR, DEPTH,
 *      and STENCIL attachments. Expect no error.
 *
 *      For default framebuffer try to invalidate part of all (COLOR, DEPTH, and
 *      STENCIL) attachments. Expect no error.
 *
 *      Create named framebuffer with maximum number of color attachments (use
 *      named renderbuffer storage), depth attachment and stencil attachment.
 *
 *      Clear all attachments.
 *
 *      Try to invalidate content of part of all attachments using
 *      InvalidateNamedFramebufferData. Expect no error.
 *
 *      Try to invalidate content of part of each attachment using
 *      InvalidateNamedFramebufferData. Expect no error.
 *
 *      Release all objects.
 */
class InvalidateSubDataTest : public deqp::TestCase
{
public:
    /* Public member functions */
    InvalidateSubDataTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    InvalidateSubDataTest(const InvalidateSubDataTest &other);
    InvalidateSubDataTest &operator=(const InvalidateSubDataTest &other);

    bool CheckErrorAndLog(const glw::GLenum attachment);
    bool CheckErrorAndLog(const glw::GLenum attachments[], const glw::GLuint count);
};
/* InvalidateSubDataTest class */

/** Clear Named Framebuffer
 *
 *      Repeat following steps for fixed-point, floating-point, signed integer,
 *      and unsigned integer color attachments.
 *
 *          Create named framebuffer with maximum number of color attachments
 *          (use named renderbuffer storage).
 *
 *          Clear each of the color attachment with unique color using proper
 *          ClearNamedFramebuffer* function.
 *
 *          For each color attachment fetch pixel data and compare that contain
 *          unique color with which it was cleared.
 *
 *          Release all objects.
 *
 *      Next, do following steps:
 *
 *          Create named framebuffer with depth attachment and stencil
 *          attachment.
 *
 *          Clear each of the attachments with unique value using proper
 *          ClearNamedFramebufferfi function.
 *
 *          Fetch pixel data of each attachment and compare that contain unique
 *          value with which it was cleared.
 *
 *          Release all objects.
 */
class ClearTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ClearTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ClearTest(const ClearTest &other);
    ClearTest &operator=(const ClearTest &other);

    void PrepareFramebuffer(glw::GLenum buffer, glw::GLenum internalformat);

    template <typename T>
    bool TestClearColor(glw::GLenum buffer, glw::GLenum attachment, T value);

    template <typename T>
    bool ClearColor(glw::GLenum buffer, glw::GLint drawbuffer, T value);

    bool TestClearDepthAndStencil(glw::GLfloat depth, glw::GLint stencil);

    template <typename T>
    glw::GLenum Format();

    template <typename T>
    glw::GLenum Type();

    template <typename T>
    bool Compare(const T first, const T second);

    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint *m_renderbuffers;
    glw::GLuint m_renderbuffers_count;
};
/* ClearTest class */

/** Blit Named Framebuffer
 *
 *      Create named framebuffer with color, depth and stencil attachments with
 *      size 2x2 pixels(use named renderbuffer storage).
 *
 *      Create named framebuffer with color, depth and stencil attachments with
 *      size 2x3 pixels(use named renderbuffer storage).
 *
 *      Clear the first framebuffer with red color, 0.5 depth and 1 as a stencil
 *      index.
 *
 *      Blit one pixel of the first framebuffer to the second framebuffer to the
 *      pixel at (0, 0) position with NEAREST filter.
 *
 *      Clear first the framebuffer with green color, 0.25 depth and 2 as a
 *      stencil index.
 *
 *      Blit one pixel of the first framebuffer to the second framebuffer to the
 *      pixel at (1, 0) position with LINEAR filter for color attachment, but
 *      NEAREST filter for depth and stencil attachments.
 *
 *      Clear the first framebuffer with blue color, 0.125 depth and 3 as a
 *      stencil index.
 *
 *      Blit the whole first framebuffer to the second framebuffer by shrinking
 *      it to the single pixel at (2, 0) position.
 *
 *      Clear the first framebuffer with yellow color, 0.0625 depth and 4 as a
 *      stencil index.
 *
 *      Blit one pixel of the framebuffer to the second framebuffer by expanding
 *      it to the three pixel constructing horizontal line at (0, 1) position.
 *
 *      Expect no error.
 *
 *      Check that color attachment of the second framebuffer has following
 *      values:
 *          red,    green,  blue,
 *          yellow, yellow, yellow.
 *
 *      Check that depth attachment of the second framebuffer has following
 *      values:
 *          0.5,    0.25,   0.125
 *          0.0625, 0.0625, 0.0625.
 *
 *      Check that stencil attachment of the second framebuffer has following
 *      values:
 *          1,  2,  3
 *          4,  4,  4.
 *
 *      Release all objects.
 */
class BlitTest : public deqp::TestCase
{
public:
    /* Public member functions */
    BlitTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    BlitTest(const BlitTest &other);
    BlitTest &operator=(const BlitTest &other);

    void PrepareFramebuffers();
    bool Test();
    void ClearFramebuffer(glw::GLfloat red, glw::GLfloat green, glw::GLfloat blue, glw::GLfloat depth,
                          glw::GLint stencil);
    bool CheckErrorAndLog();
    bool CheckColor();
    bool CheckDepth();
    bool CheckStencil();
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_src;
    glw::GLuint m_rbo_color_src;
    glw::GLuint m_rbo_depth_stencil_src;
    glw::GLuint m_fbo_dst;
    glw::GLuint m_rbo_color_dst;
    glw::GLuint m_rbo_depth_stencil_dst;
};
/* BlitTest class */

/** Check Named Framebuffer Status
 *
 *      Do following test cases:
 *
 *          Incomplete attachment case
 *
 *              Prepare framebuffer with one incomplete attachment.
 *
 *              Check the framebuffer status using CheckNamedFramebufferStatus.
 *              Expect FRAMEBUFFER_INCOMPLETE_ATTACHMENT return value.
 *
 *              Release all objects.
 *
 *              Repeat the test case for all possible color, depth and stencil
 *              attachments.
 *
 *          Missing attachment case
 *
 *              Prepare framebuffer without any attachment.
 *
 *              Check the framebuffer status using CheckNamedFramebufferStatus.
 *              Expect FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT return value.
 *
 *              Release all objects.
 *
 *          Incomplete multisample renderbuffer case
 *
 *              Prepare framebuffer with two multisampled renderbuffer color
 *              attachments which have different number of samples.
 *
 *              Check the framebuffer status using CheckNamedFramebufferStatus.
 *              Expect FRAMEBUFFER_INCOMPLETE_MULTISAMPLE return value. If the
 *              check fails return TEST_RESULT_COMPATIBILITY_WARNING.
 *
 *              Release all objects.
 *
 *          Incomplete multisample texture case
 *
 *              Prepare framebuffer with two multisampled texture color
 *              attachments and one multisampled renderbuffer which all have
 *              different number of sample locations. One of the textures shall
 *              have fixed sample locations set, one not.
 *
 *              Check the framebuffer status using CheckNamedFramebufferStatus.
 *              Expect FRAMEBUFFER_INCOMPLETE_MULTISAMPLE return value. If the
 *              check fails return TEST_RESULT_COMPATIBILITY_WARNING.
 *
 *              Release all objects.
 *
 *          Incomplete layer targets case
 *
 *              Prepare framebuffer with one 3D texture and one 2D texture.
 *
 *              Check the framebuffer status using CheckNamedFramebufferStatus.
 *              Expect FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS return value. If the
 *              check fails return TEST_RESULT_COMPATIBILITY_WARNING.
 *
 *              Release all objects.
 *
 *      Note
 *
 *      The specification is not clear about framebuffer completeness. The
 *      OpenGL 4.5 Core Profile Specification in chapter 9.4.2 says:
 *
 *          "The framebuffer object bound to target is said to be framebuffer
 *          complete if all the following conditions are true [...]"
 *
 *      It does not say that framebuffer is incomplete when any of the
 *      conditions are not met. Due to this wording, except for obvious cases
 *      (incomplete attachment and missing attachments) other tests are optional
 *      and may result in QP_TEST_RESULT_COMPATIBILITY_WARNING when fail.
 */
class CheckStatusTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CheckStatusTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CheckStatusTest(const CheckStatusTest &other);
    CheckStatusTest &operator=(const CheckStatusTest &other);

    bool IncompleteAttachmentTestCase();
    bool MissingAttachmentTestCase();
    bool IncompleteMultisampleRenderbufferTestCase();
    bool IncompleteMultisampleTextureTestCase();
    bool IncompleteLayerTargetsTestCase();
};
/* CheckStatusTest class */

/** Get Named Framebuffer Parameters
 *
 *      Prepare framebuffer with read and write buffers and renderbuffer color
 *      attachment.
 *
 *      Do following checks for the created framebuffer:
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          FRAMEBUFFER_DEFAULT_WIDTH returns the value of
 *          FRAMEBUFFER_DEFAULT_WIDTH for the framebuffer object.
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          FRAMEBUFFER_DEFAULT_HEIGHT returns the value of
 *          FRAMEBUFFER_DEFAULT_HEIGHT for the framebuffer object.
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          FRAMEBUFFER_DEFAULT_LAYERS returns the value of
 *          FRAMEBUFFER_DEFAULT_LAYERS for the framebuffer object.
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          FRAMEBUFFER_DEFAULT_SAMPLES returns the value of
 *          FRAMEBUFFER_DEFAULT_SAMPLES for the framebuffer object.
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS returns the boolean value
 *          of FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS.
 *
 *      Do following checks for the created and default (if available)
 *      framebuffer:
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          DOUBLEBUFFER returns a boolean value indicating whether double
 *          buffering is supported for the framebuffer object.
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          IMPLEMENTATION_COLOR_READ_FORMAT returns a GLenum value indicating
 *          the preferred pixel data format for the framebuffer object.
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          IMPLEMENTATION_COLOR_READ_TYPE returns a GLenum value indicating the
 *          implementation's preferred pixel data type for the framebuffer
 *          object.
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          SAMPLES returns an integer value indicating the coverage mask size
 *          for the framebuffer object.
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          SAMPLE_BUFFERS returns an integer value indicating the number of
 *          sample buffers associated with the framebuffer object.
 *
 *          Check that GetNamedFramebufferParameteriv called with parameter name
 *          STEREO returns a boolean value indicating whether stereo buffers
 *          (left and right) are supported for the framebuffer object.
 *
 *      Release all objects.
 */
class GetParametersTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetParametersTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    GetParametersTest(const GetParametersTest &other);
    GetParametersTest &operator=(const GetParametersTest &other);

    void PrepareFramebuffer();
    bool TestDefaultFramebuffer();
    bool TestCustomFramebuffer();
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
};
/* GetParametersTest class */

/** Get Named Framebuffer Attachment Parameters
 *
 *      For default framebuffer, for all attachments:
 *          FRONT_LEFT,
 *          FRONT_RIGHT,
 *          BACK_LEFT,
 *          BACK_RIGHT,
 *          DEPTH,
 *          STENCIL
 *      query FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE using
 *      GetNamedFramebufferAttachmentParameteriv function. Expect
 *      FRAMEBUFFER_DEFAULT return value (as queried with non-DSA way).
 *
 *      For any attachments not equal to GL_NONE do following queries using
 *      GetNamedFramebufferAttachmentParameteriv function:
 *          FRAMEBUFFER_ATTACHMENT_RED_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE,
 *          FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING.
 *      Expect value equal to framebuffers setup (as queried with non-DSA way).
 *      Expect no error.
 *
 *      Create 3 framebuffer objects with renderbuffer color attachment, and
 *      depth or stencil or depth-stencil attachments.
 *
 *      For each of framebuffers, for each of following attachments:
 *          DEPTH_ATTACHMENT,
 *          STENCIL_ATTACHMENT,
 *          DEPTH_STENCIL_ATTACHMENT,
 *          COLOR_ATTACHMENT0,
 *          COLOR_ATTACHMENT1
 *      query FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE using
 *      GetNamedFramebufferAttachmentParameteriv function. Expect the same
 *      return value as queried with non-DSA way.
 *
 *      For each of framebuffers, for any attachments not equal to GL_NONE do
 *      following queries using GetNamedFramebufferAttachmentParameteriv
 *      function:
 *          FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
 *          FRAMEBUFFER_ATTACHMENT_RED_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE,
 *          FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
 *      Expect value equal to framebuffers setup (as queried with non-DSA way).
 *      Expect no error.
 *
 *      Release objects.
 *
 *      Create 3 framebuffer objects with texture color attachment, and
 *      depth or stencil or depth-stencil attachments.
 *
 *      For each of framebuffers, for each of following attachments:
 *          DEPTH_ATTACHMENT,
 *          STENCIL_ATTACHMENT,
 *          DEPTH_STENCIL_ATTACHMENT,
 *          COLOR_ATTACHMENT0,
 *          COLOR_ATTACHMENT1
 *      query FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE using
 *      GetNamedFramebufferAttachmentParameteriv function. Expect the same
 *      return value as queried with non-DSA way.
 *
 *      For each of framebuffers, for any attachments not equal to GL_NONE do
 *      following queries using GetNamedFramebufferAttachmentParameteriv
 *      function:
 *          FRAMEBUFFER_ATTACHMENT_OBJECT_NAME,
 *          FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL,
 *          FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE,
 *          FRAMEBUFFER_ATTACHMENT_LAYERED,
 *          FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER,
 *          FRAMEBUFFER_ATTACHMENT_RED_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_GREEN_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_BLUE_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE,
 *          FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE,
 *          FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING
 *      Expect value equal to framebuffers setup (as queried with non-DSA way).
 *      Expect no error.
 *
 *      Release objects.
 *
 *      Additional conditions:
 *
 *          Do not query DEPTH_STENCIL_ATTACHMENT attachment if the renderbuffer
 *          or texture is not depth-stencil.
 *
 *          Do not query FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE pname with
 *          DEPTH_STENCIL_ATTACHMENT attachment.
 */
class GetAttachmentParametersTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetAttachmentParametersTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    GetAttachmentParametersTest(const GetAttachmentParametersTest &other);
    GetAttachmentParametersTest &operator=(const GetAttachmentParametersTest &other);

    void CreateRenderbufferFramebuffer(bool depth, bool stencil);
    void CreateTextureFramebuffer(bool depth, bool stencil);
    bool TestDefaultFramebuffer();
    bool TestRenderbufferFramebuffer(bool depth_stencil);
    bool TestTextureFramebuffer(bool depth_stencil);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo[2];
    glw::GLuint m_to[2];
};
/* GetParametersTest class */

/** Create Named Framebuffers Errors
 *
 *      Check that INVALID_VALUE is generated by CreateFramebuffers if n is
 *      negative.
 */
class CreationErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationErrorsTest(const CreationErrorsTest &other);
    CreationErrorsTest &operator=(const CreationErrorsTest &other);
};
/* CreationErrorsTest class */

/** Named Framebuffer Renderbuffer Errors
 *
 *      Check that INVALID_OPERATION is generated by
 *      NamedFramebufferRenderbuffer if framebuffer is not the name of an
 *      existing framebuffer object.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferRenderbuffer
 *      if attachment is COLOR_ATTACHMENTm where m is greater than or equal to
 *      the value of MAX_COLOR_ATTACHMENTS.
 *
 *      Check that INVALID_ENUM is generated by NamedFramebufferRenderbuffer if
 *      attachment is not one of the attachments in table 9.2, and attachment is
 *      not COLOR_ATTACHMENTm where m is greater than or equal to the value of
 *      MAX_COLOR_ATTACHMENTS.
 *
 *      Check that INVALID_ENUM is generated by NamedFramebufferRenderbuffer if
 *      renderbuffer target is not RENDERBUFFER.
 *
 *      Check that INVALID_OPERATION is generated by
 *      NamedFramebufferRenderbuffer if renderbuffer target is not zero or the
 *      name of an existing renderbuffer object of type RENDERBUFFER.
 */
class RenderbufferAttachmentErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    RenderbufferAttachmentErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    RenderbufferAttachmentErrorsTest(const RenderbufferAttachmentErrorsTest &other);
    RenderbufferAttachmentErrorsTest &operator=(const RenderbufferAttachmentErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, bool framebuffer, bool attachment, bool color_attachment,
                     bool renderbuffertarget, bool renderbuffer);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_rbo_valid;
    glw::GLuint m_fbo_invalid;
    glw::GLuint m_rbo_invalid;
    glw::GLenum m_color_attachment_invalid;
    glw::GLenum m_attachment_invalid;
    glw::GLenum m_renderbuffer_target_invalid;
};
/* RenderbufferAttachmentErrorsTest class */

/** Named Framebuffer Texture Errors
 *
 *      Check that GL_INVALID_OPERATION is generated by glNamedFramebufferTexture and glNamedFramebufferTextureLayer
 *      if framebuffer is not the name of an existing framebuffer object.
 *
 *      Check that INVALID_OPERATION is generated by glNamedFramebufferTexture and glNamedFramebufferTextureLayer
 *      if attachment is COLOR_ATTACHMENTm where m is greater than or equal to
 *      the value of MAX_COLOR_ATTACHMENTS.
 *
 *      Check that INVALID_ENUM is generated by glNamedFramebufferTexture and glNamedFramebufferTextureLayer if
 *      attachment is not one of the attachments in table 9.2, and attachment is
 *      not COLOR_ATTACHMENTm where m is greater than or equal to the value of
 *      MAX_COLOR_ATTACHMENTS.
 *
 *      Check that INVALID_VALUE is generated by glNamedFramebufferTexture if texture is not zero or the name
 *      of an existing texture object.
 *
 *      Check that INVALID_OPERATION is generated by glNamedFramebufferTextureLayer if texture is not zero or
 *      the name of an existing texture object.
 *
 *      Check that INVALID_VALUE is generated by glNamedFramebufferTexture and glNamedFramebufferTextureLayer if
 *      texture is not zero and level is not a supported texture level for
 *      texture.
 *
 *      Check that INVALID_OPERATION is generated by glNamedFramebufferTexture and glNamedFramebufferTextureLayer
 *      if texture is a buffer texture.
 *
 *      Check that INVALID_VALUE error is generated by NamedFramebufferTextureLayer if texture is a three-dimensional
 *      texture, and layer is larger than the value of MAX_3D_TEXTURE_SIZE minus one.
 *
 *      Check that INVALID_VALUE error is generated by NamedFramebufferTextureLayer if texture is an array texture,
 *      and layer is larger than the value of MAX_ARRAY_TEXTURE_LAYERS minus one.
 *
 *      Check that INVALID_VALUE error is generated by NamedFramebufferTextureLayer if texture is a cube map array texture,
 *      and (layer / 6) is larger than the value of MAX_CUBE_MAP_TEXTURE_SIZE minus one (see section 9.8).
 *      Check that INVALID_VALUE error is generated by NamedFramebufferTextureLayer if texture is non-zero
 *      and layer is negative.
 *
 *      Check that INVALID_OPERATION error is generated by NamedFramebufferTextureLayer if texture is non-zero
 *      and is not the name of a three-dimensional, two-dimensional multisample array, one- or two-dimensional array,
 *      or cube map array texture.
 */
class TextureAttachmentErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    TextureAttachmentErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    TextureAttachmentErrorsTest(const TextureAttachmentErrorsTest &other);
    TextureAttachmentErrorsTest &operator=(const TextureAttachmentErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function_name, bool framebuffer, bool attachment,
                     bool color_attachment, bool texture, bool level, const glw::GLchar *texture_type, bool layer);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_to_valid;
    glw::GLuint m_to_3d_valid;
    glw::GLuint m_to_array_valid;
    glw::GLuint m_to_cubearray_valid;
    glw::GLuint m_tbo_valid;
    glw::GLuint m_fbo_invalid;
    glw::GLuint m_to_invalid;
    glw::GLuint m_to_layer_invalid; /* it is valid rectangle texture, but invalid for NamedFramebufferTextureLayer */
    glw::GLenum m_color_attachment_invalid;
    glw::GLenum m_attachment_invalid;
    glw::GLint m_level_invalid;
    glw::GLint m_max_3d_texture_size;
    glw::GLint m_max_3d_texture_depth;
    glw::GLint m_max_array_texture_layers;
    glw::GLint m_max_cube_map_texture_size;
};
/* TextureAttachmentErrorsTest class */

/** Named Framebuffer Draw Read Buffers Errors
 *
 *      Check that INVALID_OPERATION error is generated by
 *      NamedFramebufferDrawBuffer if framebuffer is not zero or the name of an
 *      existing framebuffer object.
 *
 *      Check that INVALID_ENUM is generated by NamedFramebufferDrawBuffer if
 *      buf is not an accepted value.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferDrawBuffer
 *      if the GL is bound to a draw framebuffer object and the ith argument is
 *      a value other than COLOR_ATTACHMENTi or NONE.
 *
 *      Check that INVALID_OPERATION error is generated by
 *      NamedFramebufferDrawBuffers if framebuffer is not zero or the name of an
 *      existing framebuffer object.
 *
 *      Check that INVALID_VALUE is generated by NamedFramebufferDrawBuffers if
 *      n is less than 0.
 *
 *      Check that INVALID_VALUE is generated by NamedFramebufferDrawBuffers if
 *      n is greater than MAX_DRAW_BUFFERS.
 *
 *      Check that INVALID_ENUM is generated by NamedFramebufferDrawBuffers if
 *      one of the values in bufs is not an accepted value.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferDrawBuffers
 *      if a symbolic constant other than GL_NONE appears more than once in
 *      bufs.
 *
 *      Check that INVALID_ENUM error is generated by
 *      NamedFramebufferDrawBuffers if any value in bufs is FRONT, LEFT, RIGHT,
 *      or FRONT_AND_BACK. This restriction applies to both the default
 *      framebuffer and framebuffer objects, and exists because these constants
 *      may themselves refer to multiple buffers, as shown in table 17.4.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferDrawBuffers
 *      if any value in bufs is BACK, and n is not one.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferDrawBuffers
 *      if the API call refers to a framebuffer object and one or more of the
 *      values in bufs is anything other than NONE or one of the
 *      COLOR_ATTACHMENTn tokens.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferDrawBuffers
 *      if the API call refers to the default framebuffer and one or more of the
 *      values in bufs is one of the COLOR_ATTACHMENTn tokens.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferReadBuffer
 *      if framebuffer is not zero or the name of an existing framebuffer
 *      object.
 *
 *      Check that INVALID_ENUM is generated by NamedFramebufferReadBuffer if
 *      src is not one of the accepted values (tables 17.4 and 17.5 of OpenGL
 *      4.5 Core Profile Specification).
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferReadBuffer
 *      if the default framebuffer is affected and src is a value (other than
 *      NONE) that does not indicate any of the color buffers allocated to the
 *      default framebuffer.
 *
 *      Check that INVALID_OPERATION is generated by NamedFramebufferReadBuffer
 *      if a framebuffer object is affected, and src is one of the  constants
 *      from table 17.4 (other than NONE, or COLOR_ATTACHMENTm where m is
 *      greater than or equal to the value of MAX_COLOR_ATTACHMENTS).
 */
class DrawReadBuffersErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DrawReadBuffersErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    DrawReadBuffersErrorsTest(const DrawReadBuffersErrorsTest &other);
    DrawReadBuffersErrorsTest operator=(const DrawReadBuffersErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_fbo_invalid;
    glw::GLenum m_attachment_color;
    glw::GLenum m_attachment_back_left;
    glw::GLenum m_attachment_right;
    glw::GLenum m_attachment_left;
    glw::GLenum m_attachment_front;
    glw::GLenum m_attachment_front_and_back;
    glw::GLenum m_attachment_back;
    glw::GLenum m_attachment_invalid;
    glw::GLenum m_attachments_invalid[2];
    glw::GLenum m_attachments_back_invalid[2];
    glw::GLint m_attachments_too_many_count;
    glw::GLenum *m_attachments_too_many;
    glw::GLint m_max_color_attachments;
};
/* DrawReadBuffersErrorsTest class */

/** Invalidate Framebuffer Data and SubData Errors

 Check that INVALID_OPERATION error is generated by
 InvalidateNamedFramebufferData if framebuffer is not zero or the name of
 an existing framebuffer object.

 Check that INVALID_ENUM error is generated by
 InvalidateNamedFramebufferData if a framebuffer object is affected, and
 any element of of attachments is not one of the values
 {COLOR_ATTACHMENTi, DEPTH_ATTACHMENT, STENCIL_ATTACHMENT,
 DEPTH_STENCIL_ATTACHMENT}.

 Check that INVALID_OPERATION error is generated by
 InvalidateNamedFramebufferData if attachments contains COLOR_ATTACHMENTm
 where m is greater than or equal to the value of MAX_COLOR_ATTACHMENTS.

 Check that INVALID_ENUM error is generated by
 InvalidateNamedFramebufferData if the default framebuffer is affected,
 and any elements of attachments are not one of:
 -  FRONT_LEFT, FRONT_RIGHT, BACK_LEFT, and BACK_RIGHT, identifying that
 specific buffer,
 -  COLOR, which is treated as BACK_LEFT for a double-buffered context
 and FRONT_LEFT for a single-buffered context,
 -  DEPTH, identifying the depth buffer,
 -  STENCIL, identifying the stencil buffer.

 Check that INVALID_OPERATION error is generated by
 InvalidateNamedSubFramebuffer if framebuffer is not zero or the name of
 an existing framebuffer object.

 Check that INVALID_VALUE error is generated by
 InvalidateNamedSubFramebuffer if numAttachments, width, or height is
 negative.

 Check that INVALID_ENUM error is generated by
 InvalidateNamedSubFramebuffer if a framebuffer object is affected, and
 any element of attachments is not one of the values {COLOR_ATTACHMENTi,
 DEPTH_ATTACHMENT, STENCIL_ATTACHMENT, DEPTH_STENCIL_ATTACHMENT}.

 Check that INVALID_OPERATION error is generated by
 InvalidateNamedSubFramebuffer if attachments contains COLOR_ATTACHMENTm
 where m is greater than or equal to the value of MAX_COLOR_ATTACHMENTS.

 Check that INVALID_ENUM error is generated by
 InvalidateNamedSubFramebuffer if the default framebuffer is affected,
 and any elements of attachments are not one of:
 -  FRONT_LEFT, FRONT_RIGHT, BACK_LEFT, and BACK_RIGHT, identifying that
 specific buffer,
 -  COLOR, which is treated as BACK_LEFT for a double-buffered context
 and FRONT_LEFT for a single-buffered context,
 -  DEPTH, identifying the depth buffer,
 -  STENCIL, identifying the stencil buffer.
 */
class InvalidateDataAndSubDataErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    InvalidateDataAndSubDataErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    InvalidateDataAndSubDataErrorsTest(const InvalidateDataAndSubDataErrorsTest &other);
    InvalidateDataAndSubDataErrorsTest operator=(const InvalidateDataAndSubDataErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_rbo;
    glw::GLuint m_fbo_invalid;
    glw::GLenum m_fbo_attachment_valid;
    glw::GLenum m_fbo_attachment_invalid;
    glw::GLenum m_color_attachment_invalid;
    glw::GLenum m_default_attachment_invalid;
};
/* InvalidateDataAndSubDataErrorsTest class */

/** Clear Named Framebuffer Errors
 *
 *      Check that INVALID_OPERATION is generated by ClearNamedFramebuffer* if
 *      framebuffer is not zero or the name of an existing framebuffer object.
 *
 *      Check that INVALID_ENUM is generated by ClearNamedFramebufferiv buffer
 *      is not COLOR or STENCIL.
 *
 *      Check that INVALID_ENUM is generated by ClearNamedFramebufferuiv buffer
 *      is not COLOR.
 *
 *      Check that INVALID_ENUM is generated by ClearNamedFramebufferfv buffer
 *      is not COLOR or DEPTH.
 *
 *      Check that INVALID_ENUM is generated by ClearNamedFramebufferfi buffer
 *      is not DEPTH_STENCIL.
 *
 *      Check that INVALID_VALUE is generated if buffer is COLOR drawbuffer is
 *      negative, or greater than the value of MAX_DRAW_BUFFERS minus one.
 *
 *      Check that INVALID_VALUE is generated if buffer is DEPTH, STENCIL or
 *      DEPTH_STENCIL and drawbuffer is not zero.
 */
class ClearNamedFramebufferErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ClearNamedFramebufferErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    ClearNamedFramebufferErrorsTest(const ClearNamedFramebufferErrorsTest &other);
    ClearNamedFramebufferErrorsTest &operator=(const ClearNamedFramebufferErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_rbo_color;
    glw::GLuint m_rbo_depth_stencil;
    glw::GLuint m_fbo_invalid;
};
/* ClearNamedFramebufferErrorsTest class */

/** Check Named Framebuffer Status Errors
 *
 *      Check that INVALID_ENUM is generated by CheckNamedFramebufferStatus if
 *      target is not DRAW_FRAMEBUFFER, READ_FRAMEBUFFER or FRAMEBUFFER.
 *
 *      Check that INVALID_OPERATION is generated by CheckNamedFramebufferStatus
 *      if framebuffer is not zero or the name of an existing framebuffer
 *      object.
 */
class CheckStatusErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CheckStatusErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CheckStatusErrorsTest(const CheckStatusErrorsTest &other);
    CheckStatusErrorsTest &operator=(const CheckStatusErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_fbo_invalid;
    glw::GLuint m_target_invalid;
};
/* CheckStatusErrorsTest class */

/** Get Named Framebuffer Parameter Errors
 *
 *      Check that INVALID_OPERATION is generated by
 *      GetNamedFramebufferParameteriv if framebuffer is not zero or the name of
 *      an existing framebuffer object.
 *
 *      Check that INVALID_ENUM is generated by GetNamedFramebufferParameteriv
 *      if pname is not one of the accepted parameter names.
 *
 *      Check that INVALID_OPERATION is generated if a default framebuffer is
 *      queried, and pname is not one of DOUBLEBUFFER,
 *      IMPLEMENTATION_COLOR_READ_FORMAT, IMPLEMENTATION_COLOR_READ_TYPE,
 *      SAMPLES, SAMPLE_BUFFERS or STEREO.
 */
class GetParameterErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetParameterErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    GetParameterErrorsTest(const GetParameterErrorsTest &other);
    GetParameterErrorsTest &operator=(const GetParameterErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_fbo_invalid;
    glw::GLuint m_parameter_invalid;
};
/* GetParameterErrorsTest class */

/** Get Named Framebuffer Attachment Parameter Errors
 *
 *      Check that GL_INVALID_OPERATION is generated by
 *      GetNamedFramebufferAttachmentParameteriv if framebuffer is not zero or
 *      the name of an existing framebuffer object.
 *
 *      Check that INVALID_ENUM is generated by
 *      GetNamedFramebufferAttachmentParameteriv if pname is not valid for the
 *      value of GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, as described above.
 *
 *      Check that INVALID_ENUM error is generated if a framebuffer object is queried, attachment
 *      is not one of the attachments in table 9.2 (COLOR_ATTACHMENTi, DEPTH_ATTACHMENT, STENCIL_ATTACHMENT, DEPTH_STENCIL_ATTACHMENT), and attachment is not
 *      COLOR_ATTACHMENTm where m is greater than or equal to the value of MAX_COLOR_ATTACHMENTS.
 *
 *      Check that INVALID_OPERATION is generated by
 *      GetNamedFramebufferAttachmentParameteriv if the value of
 *      FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE is GL_NONE and pname is not
 *      FRAMEBUFFER_ATTACHMENT_OBJECT_NAME or
 *      FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE.
 *
 *      Check that INVALID_OPERATION is generated by
 *      GetNamedFramebufferAttachmentParameteriv if attachment is
 *      DEPTH_STENCIL_ATTACHMENT and pname is
 *      FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE.
 *
 *      Check that an INVALID_ENUM error is generated if the default framebuffer is
 *      queried and attachment is not one the values specified in table 9.1.
 *
 *      Check that an INVALID_OPERATION error is generated if a framebuffer object is
 *      bound to target and attachment is COLOR_ATTACHMENTm where m is greater than or
 *      equal to the value of MAX_COLOR_ATTACHMENTS.
 *
 *      Check that an INVALID_ENUM error is generated if a framebuffer object is
 *      queried, attachment is not one of the attachments in table 9.2, and attachment
 *      is not COLOR_ATTACHMENTm where m is greater than or equal to the value of
 *      MAX_COLOR_ATTACHMENTS.
 */
class GetAttachmentParameterErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetAttachmentParameterErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    GetAttachmentParameterErrorsTest(const GetAttachmentParameterErrorsTest &other);
    GetAttachmentParameterErrorsTest &operator=(const GetAttachmentParameterErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_valid;
    glw::GLuint m_rbo_color;
    glw::GLuint m_rbo_depth_stencil;
    glw::GLuint m_fbo_invalid;
    glw::GLuint m_parameter_invalid;
    glw::GLenum m_attachment_invalid;
    glw::GLenum m_default_attachment_invalid;
    glw::GLint m_max_color_attachments;
};
/* GetAttachmentParameterErrorsTest class */

/** Framebuffer and Renderbuffer Functional
 *
 *      Create two framebuffer objects using CreateFramebuffers.
 *
 *      Setup first framebuffer with renderbuffer color, depth and stencil
 *      attachments. Setup storage size with width and height equal to 8. Set
 *      them as draw and read buffers. Clean up it, use black color. Check the
 *      framebuffer status.
 *
 *      Setup second framebuffer with texture color attachment. Setup storage
 *      size with width equal to 4 and height equal to 3.  Check the framebuffer
 *      status.
 *
 *      Prepare GLSL program which can draw triangles using orthographic
 *      projection. Fragment shader
 *
 *      Clean both framebuffers using ClearNamedFramebuffer* functions.
 *
 *      Use first framebuffer.
 *
 *      Draw to stencil a quad with screen positions [-0.5, -0.5], [-0.5, 0.5],
 *      [0.5, -0.5] and [0.5, 0.5].
 *
 *      Draw to depth buffer a quad with positions [-1, -1, -1], [-1, 1, -1],
 *      [1, -1, 0] and [1, 1, 0].
 *
 *      Turn on depth and stencil tests. Depth test shall pass if incoming depth
 *      value is LESS than stored. The Stencil test shall pass only for any
 *      stencil pass.
 *
 *      Draw Full screen quad to draw buffer with z = 0.5.
 *
 *      Blit the color content of the first framebuffer to the second with
 *      nearest filter.
 *
 *      Fetch data. Expect that second framebuffer contain following data
 *          black,  black,  black,  black,
 *          black,  black,  white,  black,
 *          black,  black,  black,  black.
 */
class FunctionalTest : public deqp::TestCase
{
public:
    /* Public member functions */
    FunctionalTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    FunctionalTest(const FunctionalTest &other);
    FunctionalTest &operator=(const FunctionalTest &other);

    bool PrepareFirstFramebuffer();
    bool PrepareSecondFramebuffer();
    bool ClearFramebuffers();
    void PrepareProgram();
    void PrepareBuffersAndVertexArrays();
    bool DrawAndBlit();
    bool CheckSecondFramebufferContent();
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo_1st;
    glw::GLuint m_fbo_2nd;
    glw::GLuint m_rbo_color;
    glw::GLuint m_rbo_depth_stencil;
    glw::GLuint m_to_color;
    glw::GLuint m_po;
    glw::GLuint m_vao_stencil_pass_quad;
    glw::GLuint m_vao_depth_pass_quad;
    glw::GLuint m_vao_color_pass_quad;
    glw::GLuint m_bo_stencil_pass_quad;
    glw::GLuint m_bo_depth_pass_quad;
    glw::GLuint m_bo_color_pass_quad;

    /* Private static variables. */
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
    static const glw::GLchar s_attribute[];
    static const glw::GLfloat s_stencil_pass_quad[];
    static const glw::GLfloat s_depth_pass_quad[];
    static const glw::GLfloat s_color_pass_quad[];
    static const glw::GLuint s_stencil_pass_quad_size;
    static const glw::GLuint s_depth_pass_quad_size;
    static const glw::GLuint s_color_pass_quad_size;
};
/* FunctionalTest class */
} // namespace Framebuffers

namespace Renderbuffers
{
/** Renderbuffer Creation
 *
 *      Create at least two renderbuffer objects using GenRenderbuffers
 *      function. Check them without binding, using IsRenderbuffer function.
 *      Expect FALSE.
 *
 *      Create at least two renderbuffer objects using CreateRenderbuffers
 *      function. Check them without binding, using IsRenderbuffer function.
 *      Expect TRUE.
 *
 *      Release objects.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** Named Renderbuffer Storage
 *
 *      Create renderbuffer object. Prepare its storage using
 *      NamedRenderbufferStorage function.
 *
 *      Create framebuffer object. Attach renderbuffer to proper attachment
 *      point.
 *
 *      Clear framebuffer's renderbuffer attachment with reference value. Fetch
 *      the data from framebuffer's attachment using ReadPixels. Compare the
 *      fetched values with the reference.
 *
 *      Release all objects.
 *
 *      Repeat the test for following internal formats:
 *
 *          R8, R16, RG8, RG16, RGB565, RGBA4, RGB5_A1, RGBA8, RGB10_A2,
 *          RGB10_A2UI, RGBA16, SRGB8_ALPHA8, R16F, RG16F, RGBA16F, R32F, RG32F,
 *          RGBA32F, R11F_G11F_B10F, R8I, R8UI, R16I, R16UI, R32I, R32UI, RG8I,
 *          RG8UI, RG16I, RG16UI, RG32I, RG32UI, RGBA8I, RGBA8UI, RGBA16I,
 *          RGBA16UI, RGBA32I, RGBA32UI, DEPTH_COMPONENT16, DEPTH_COMPONENT24,
 *          DEPTH_COMPONENT32F, DEPTH24_STENCIL8, DEPTH32F_STENCIL8 and
 *          STENCIL_INDEX8.
 *
 *      Repeat the test for following width and height:
 *          width = 1 and height = 1;
 *          width = 256 and height = 512;
 *          width = 1280 and height = 720;
 *          width = value of MAX_RENDERBUFFER_SIZE and height = 1;
 *          width = 1 and height = value of MAX_RENDERBUFFER_SIZE.
 */
class StorageTest : public deqp::TestCase
{
public:
    /* Public member functions */
    StorageTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private static variables. */
    static const struct RenderbufferInternalFormatConfiguration
    {
        glw::GLenum internalformat;
        const glw::GLchar *internalformat_name;
        bool hasRedComponent;
        bool hasGreenComponent;
        bool hasBlueComponent;
        bool hasAlphaComponent;
        bool hasDepthComponent;
        bool hasStencilComponent;
        bool isColorIntegralFormat;
    } s_renderbuffer_internalformat_configuration[];

    static const glw::GLuint s_renderbuffer_internalformat_configuration_count;

    static const glw::GLfloat s_reference_color[4];
    static const glw::GLint s_reference_color_integer[4];
    static const glw::GLfloat s_reference_depth;
    static const glw::GLint s_reference_stencil;

    /* Private member functions */
    StorageTest(const StorageTest &other);
    StorageTest &operator=(const StorageTest &other);

    bool PrepareRenderbuffer(StorageTest::RenderbufferInternalFormatConfiguration format, glw::GLuint width,
                             glw::GLuint height);
    void Clear(bool isIntegralFormat);
    bool Check(StorageTest::RenderbufferInternalFormatConfiguration format, glw::GLuint width, glw::GLuint height);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
};
/* StorageTest class */

/** Named Renderbuffer Storage Multisample
 *
 *      Create two renderbuffer objects. Prepare storage of the first one using
 *      NamedRenderbufferStorageMultisample function. Prepare storage of the
 *      second one using NamedRenderbufferStorage function.
 *
 *      Create two framebuffer objects. Attach multisampled renderbuffer to
 *      proper attachment points of the first framebuffer. Attach second
 *      renderbuffer to proper attachment points of the second framebuffer.
 *
 *      Clear framebuffer's renderbuffer attachment with reference value. Blit
 *      surface of the first framebuffer (multisampled renderbuffer) to the
 *      second framebuffer. Fetch the data from the second framebuffer using
 *      ReadPixels function. Compare the fetched values with the reference.
 *
 *      Release all objects.
 *
 *      Repeat the test for following internal formats:
 *
 *          R8, R16, RG8, RG16, RGB565, RGBA4, RGB5_A1, RGBA8, RGB10_A2,
 *          RGB10_A2UI, RGBA16, SRGB8_ALPHA8, R16F, RG16F, RGBA16F, R32F, RG32F,
 *          RGBA32F, R11F_G11F_B10F, R8I, R8UI, R16I, R16UI, R32I, R32UI, RG8I,
 *          RG8UI, RG16I, RG16UI, RG32I, RG32UI, RGBA8I, RGBA8UI, RGBA16I,
 *          RGBA16UI, RGBA32I, RGBA32UI, DEPTH_COMPONENT16, DEPTH_COMPONENT24,
 *          DEPTH_COMPONENT32F, DEPTH24_STENCIL8, DEPTH32F_STENCIL8 and
 *          STENCIL_INDEX8.
 *
 *      Repeat the test for following width and height:
 *          width = 1 and height = 1;
 *          width = value of MAX_RENDERBUFFER_SIZE and height = 1;
 *          width = 1 and height = value of MAX_RENDERBUFFER_SIZE.
 *
 *      Repeat the test for number of samples in range from 1 to value of
 *      MAX_INTEGER_SAMPLES for signed and unsigned integer internal formats or
 *      in range from 1 to value of MAX_SAMPLES for all other internal formats.
 */
class StorageMultisampleTest : public deqp::TestCase
{
public:
    /* Public member functions */
    StorageMultisampleTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private static variables. */
    static const struct RenderbufferInternalFormatConfiguration
    {
        glw::GLenum internalformat;
        const glw::GLchar *internalformat_name;
        bool hasRedComponent;
        bool hasGreenComponent;
        bool hasBlueComponent;
        bool hasAlphaComponent;
        bool hasDepthComponent;
        bool hasStencilComponent;
        bool isColorIntegralFormat;
    } s_renderbuffer_internalformat_configuration[];

    static const glw::GLuint s_renderbuffer_internalformat_configuration_count;

    static const glw::GLfloat s_reference_color[4];
    static const glw::GLint s_reference_color_integer[4];
    static const glw::GLfloat s_reference_depth;
    static const glw::GLint s_reference_stencil;

    /* Private member functions */
    StorageMultisampleTest(const StorageMultisampleTest &other);
    StorageMultisampleTest &operator=(const StorageMultisampleTest &other);

    bool PrepareRenderbuffer(StorageMultisampleTest::RenderbufferInternalFormatConfiguration format, glw::GLuint width,
                             glw::GLuint height, glw::GLsizei samples);
    void Bind(glw::GLenum target, glw::GLuint selector);
    void Blit(glw::GLuint width, glw::GLuint height);
    void Clear(bool isIntegralFormat);
    bool Check(StorageMultisampleTest::RenderbufferInternalFormatConfiguration format, glw::GLuint width,
               glw::GLuint height);
    void Clean();
    glw::GLint GetMaxConformantSampleCount(glw::GLenum target, glw::GLenum internalFormat);

    /* Private member variables. */
    glw::GLuint m_fbo[2];
    glw::GLuint m_rbo[2];
};
/* StorageMultisampleTest class */

/** Get Named Renderbuffer Parameter
 *
 *      Create named renderbuffer object with varying width = 1,
 *      height = 2, and varying internalformat.
 *
 *      For following parameter names:
 *       -  RENDERBUFFER_WIDTH,
 *       -  RENDERBUFFER_HEIGHT,
 *       -  RENDERBUFFER_INTERNAL_FORMAT,
 *       -  RENDERBUFFER_SAMPLES,
 *       -  RENDERBUFFER_RED_SIZE,
 *       -  RENDERBUFFER_GREEN_SIZE,
 *       -  RENDERBUFFER_BLUE_SIZE,
 *       -  RENDERBUFFER_ALPHA_SIZE,
 *       -  RENDERBUFFER_DEPTH_SIZE,
 *       -  RENDERBUFFER_STENCIL_SIZE
 *      query value using GetNamedRenderbufferParameteriv. Expect no error.
 *      Compare it with value returned in non-DSA way. Expect equality.
 *
 *      Repeat test for following internalformats:
 *       -  RGBA8,
 *       -  DEPTH_COMPONENT24,
 *       -  STENCIL_INDEX8,
 *       -  DEPTH24_STENCIL8.
 *
 *      Release objects.
 */
class GetParametersTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetParametersTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    GetParametersTest(const GetParametersTest &other);
    GetParametersTest &operator=(const GetParametersTest &other);

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
};
/* GetParametersTest class */

/** Create Renderbuffer Errors
 *
 *      Check that INVALID_VALUE is generated by CreateRenderbuffers if n is
 *      negative.
 */
class CreationErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationErrorsTest(const CreationErrorsTest &other);
    CreationErrorsTest &operator=(const CreationErrorsTest &other);
};
/* CreationErrorsTest class */

/** Named Renderbuffer Storage Errors
 *
 *      Check that INVALID_OPERATION is generated by NamedRenderbufferStorage if
 *      renderbuffer is not the name of an existing renderbuffer object.
 *
 *      Check that INVALID_VALUE is generated by NamedRenderbufferStorage if
 *      either of width or height is negative, or greater than the value of
 *      MAX_RENDERBUFFER_SIZE.
 */
class StorageErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    StorageErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    StorageErrorsTest(const StorageErrorsTest &other);
    StorageErrorsTest &operator=(const StorageErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_rbo_valid;
    glw::GLuint m_rbo_invalid;
    glw::GLenum m_internalformat_invalid;
};
/* StorageErrorsTest class */

/** Named Renderbuffer Storage Multisample Errors
 *
 *      Check that INVALID_OPERATION is generated by
 *      NamedRenderbufferStorageMultisample function if renderbuffer is not the
 *      name of an existing renderbuffer object.
 *
 *      Check that INVALID_VALUE is generated by
 *      NamedRenderbufferStorageMultisample if samples is greater than
 *      MAX_SAMPLES.
 *
 *      Check that INVALID_ENUM is generated by
 *      NamedRenderbufferStorageMultisample if internalformat is not a
 *      color-renderable, depth-renderable, or stencil-renderable format.
 *
 *      Check that INVALID_OPERATION is generated by
 *      NamedRenderbufferStorageMultisample if internalformat is a signed or
 *      unsigned integer format and samples is greater than the value of
 *      MAX_INTEGER_SAMPLES.
 *
 *      Check that INVALID_VALUE is generated by
 *      NamedRenderbufferStorageMultisample if either of width or height is
 *      negative, or greater than the value of GL_MAX_RENDERBUFFER_SIZE.
 */
class StorageMultisampleErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    StorageMultisampleErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    StorageMultisampleErrorsTest(const StorageMultisampleErrorsTest &other);
    StorageMultisampleErrorsTest &operator=(const StorageMultisampleErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_rbo_valid;
    glw::GLuint m_rbo_invalid;
    glw::GLenum m_internalformat_invalid;
    glw::GLint m_max_samples;
    glw::GLint m_max_integer_samples;
};
/* StorageMultisampleErrorsTest class */

/** Get Named Renderbuffer Parameter Errors
 *
 *      Check that INVALID_OPERATION is generated by
 *      GetNamedRenderbufferParameteriv if renderbuffer is not the name of an
 *      existing renderbuffer object.
 *
 *      Check that INVALID_ENUM is generated by GetNamedRenderbufferParameteriv
 *      if parameter name is not one of the accepted parameter names described
 *      in specification.
 */
class GetParameterErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetParameterErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    GetParameterErrorsTest(const GetParameterErrorsTest &other);
    GetParameterErrorsTest &operator=(const GetParameterErrorsTest &other);

    void PrepareObjects();
    bool ExpectError(glw::GLenum expected_error, const glw::GLchar *function, const glw::GLchar *conditions);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_rbo_valid;
    glw::GLuint m_rbo_invalid;
    glw::GLenum m_parameter_invalid;
};
/* GetParameterErrorsTest class */
} // namespace Renderbuffers

namespace VertexArrays
{
/** Vertex Array Object Creation
 *
 *     Create at least two vertex array objects using GenVertexArrays function.
 *     Check them without binding, using IsVertexArray function. Expect FALSE.
 *
 *     Create at least two vertex array objects using CreateVertexArrays
 *     function. Check them without binding, using IsVertexArray function.
 *     Expect TRUE.
 *
 *     Release objects.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

/** Vertex Array Object Enable Disable Attributes
 *
 *      Prepare vertex shader with (MAX_VERTEX_ATTRIBS / 2) attribute variables.
 *      Vertex shader shall sum all input attribute variables and pass the sum
 *      to transform feedback varying. Build program in two versions:
 *          1) with attribute variable names bound to even attribute indexes;
 *          2) with attribute variable names bound to odd attribute indexes.
 *
 *      Prepare and bind vertex array object.
 *
 *      Prepare buffer object with MAX_VERTEX_ATTRIBS of consecutive numbers.
 *      Bound each of the numbers to separate index. Prepare second object for
 *      transform feedback result.
 *
 *      Unbind vertex array object.
 *
 *      Enable even attribute indexes using EnableVertexArrayAttrib. Expect no
 *      error.
 *
 *      Bind vertex array object.
 *
 *      Use first program. Draw single point using transform feedback. Expect
 *      sum of numbers at even positions in the input (reference) buffer object.
 *
 *      Unbind vertex array object.
 *
 *      Disable even attribute indexes using DisableVertexArrayAttrib. Expect no
 *      error.
 *
 *      Enable odd attribute indexes using EnableVertexArrayAttrib. Expect no
 *      error.
 *
 *      Bind vertex array object.
 *
 *      Use second program. Draw single point using transform feedback. Expect
 *      sum of numbers at odd positions in the input (reference) buffer object.
 *
 *      Unbind vertex array object.
 *
 *      Release all objects.
 */
class EnableDisableAttributesTest : public deqp::TestCase
{
public:
    /* Public member functions */
    EnableDisableAttributesTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    EnableDisableAttributesTest(const EnableDisableAttributesTest &other);
    EnableDisableAttributesTest &operator=(const EnableDisableAttributesTest &other);

    glw::GLuint PrepareProgram(const bool bind_even_or_odd);
    glw::GLuint BuildProgram(const char *vertex_shader, const bool bind_even_or_odd);
    void PrepareVAO();
    void PrepareXFB();
    bool DrawAndCheck(bool bind_even_or_odd);
    bool TurnOnAttributes(bool enable_even, bool enable_odd);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_po_even;
    glw::GLuint m_po_odd;
    glw::GLuint m_vao;
    glw::GLuint m_bo;
    glw::GLuint m_bo_xfb;
    glw::GLint m_max_attributes;

    /* Private static constants. */
    static const glw::GLchar s_vertex_shader_template[];
    static const glw::GLchar s_fragment_shader[];
};
/* EnableDisableAttributesTest class */

/** Vertex Array Object Element Buffer
 *
 *      Prepare GLSL program which passes input attribute to transform feedback
 *      varying.
 *
 *      Create and bind vertex array object.
 *
 *      Prepare buffer object with integer data {2, 1, 0}. Set this buffer as an
 *      input attribute. Use non-DSA functions.
 *
 *      Unbind vertex array object.
 *
 *      Prepare buffer object with integer data {2, 1, 0}. Set this buffer as an
 *      element buffer using VertexArrayElementBuffer function.
 *
 *      Bind vertex array object.
 *
 *      Use the program. Draw three points using transform feedback. Expect
 *      result equal to {0, 1, 2}.
 *
 *      Release all objects.
 */
class ElementBufferTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ElementBufferTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    ElementBufferTest(const ElementBufferTest &other);
    ElementBufferTest &operator=(const ElementBufferTest &other);

    void PrepareProgram();
    bool PrepareVAO();
    void PrepareXFB();
    bool DrawAndCheck();
    void Clean();

    /* Private member variables. */
    glw::GLuint m_po;
    glw::GLuint m_vao;
    glw::GLuint m_bo_array;
    glw::GLuint m_bo_elements;
    glw::GLuint m_bo_xfb;

    /* Private static constants. */
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
};
/* ElementBufferTest class */

/** Vertex Array Object Vertex Buffer and Buffers
 *
 *      Prepare GLSL program which passes sum of three input integer attributes
 *      to the transform feedback varying.
 *
 *      Prepare two vertex buffer objects. Setup first buffer with data {0, 1,
 *      2, 3}.
 *      Setup second buffer with data {4, 5}.
 *
 *      Create vertex array object. Setup three vertex attributes. Set first
 *      buffer object as an input attribute 0 and 1 in interleaved way using
 *      VertexArrayVertexBuffer function. Set second buffer object as an input
 *      attribute 2 using VertexArrayVertexBuffer function.
 *
 *      Use program. Draw 2 points using transform feedback. Query results.
 *      Expect two values {0+2+4, 1+3+5}.
 *
 *      Release all data.
 *
 *      Repeat the test using VertexArrayVertexBuffers function instead of
 *      VertexArrayVertexBuffer.
 */
class VertexBuffersTest : public deqp::TestCase
{
public:
    /* Public member functions */
    VertexBuffersTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    VertexBuffersTest(const VertexBuffersTest &other);
    VertexBuffersTest &operator=(const VertexBuffersTest &other);

    void PrepareProgram();
    bool PrepareVAO(bool use_multiple_buffers_function);
    void PrepareXFB();
    bool DrawAndCheck();
    void Clean();

    /* Private member variables. */
    glw::GLuint m_po;
    glw::GLuint m_vao;
    glw::GLuint m_bo_array_0;
    glw::GLuint m_bo_array_1;
    glw::GLuint m_bo_xfb;

    /* Private static constants. */
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
};
/* VertexBuffersTest class */

/** Vertex Array Object Attribute Format
 *
 *      Prepare GLSL program which passes sum of two input attributes to the
 *      transform feedback varying.
 *
 *      Create vertex array object.
 *
 *      Prepare vertex buffer object with reference data of two interleaved
 *      arrays. Setup it as input interleaved attributes.
 *
 *      Setup two consecutive attributes using VertexArrayAttribFormat function.
 *
 *      Use program. Draw 2 points using transform feedback. Query results.
 *      Expect sum of adequate reference values.
 *
 *      Release all data.
 *
 *      Repeat the test using VertexArrayAttribIFormat VertexArrayAttribLFormat
 *      function instead of VertexArrayAttribFormat.
 *
 *      Repeat the test using size 1, 2, 3, and 4 (if possible by type).
 *
 *      Repeat the test using type BYTE, SHORT, INT, FLOAT, DOUBLE,
 *      UNSIGNED_BYTE, UNSIGNED_SHORT, UNSIGNED_INT.
 *
 *      For test with VertexArrayAttribFormat function repeat for normalized and
 *      not normalized values.
 */
class AttributeFormatTest : public deqp::TestCase
{
public:
    /* Public member functions */
    AttributeFormatTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private state enumerations. */
    enum AtributeFormatFunctionType
    {
        ATTRIBUTE_FORMAT_FUNCTION_FLOAT,
        ATTRIBUTE_FORMAT_FUNCTION_DOUBLE,
        ATTRIBUTE_FORMAT_FUNCTION_INTEGER,
        ATTRIBUTE_FORMAT_FUNCTION_COUNT /* Must be last */
    };

    /* Private member functions. */
    AttributeFormatTest(const AttributeFormatTest &other);
    AttributeFormatTest &operator=(const AttributeFormatTest &other);

    template <typename T>
    bool compare(T a, T b);

    void PrepareProgram(glw::GLint size, AtributeFormatFunctionType function_selector);

    template <typename T>
    glw::GLdouble NormalizationScaleFactor();

    template <typename T>
    bool PrepareVAO(glw::GLint size, glw::GLenum type_gl_name, bool normalized,
                    AtributeFormatFunctionType function_selector);

    void PrepareXFB();

    template <typename T>
    bool DrawAndCheck(glw::GLint size, bool normalized);

    void CleanVAO();
    void CleanProgram();
    void CleanXFB();

    /* Private member variables. */
    glw::GLuint m_po;
    glw::GLuint m_vao;
    glw::GLuint m_bo_array;
    glw::GLuint m_bo_xfb;

    /* Private static constants. */
    static const glw::GLchar *s_vertex_shader_head;
    static const glw::GLchar *s_vertex_shader_body;
    static const glw::GLchar *s_vertex_shader_declaration[ATTRIBUTE_FORMAT_FUNCTION_COUNT][4 /* sizes count */];
    static const glw::GLchar *s_fragment_shader;
};
/* AttributeFormatTest class */

/** Vertex Array Attribute Binding
 *
 *      Prepare GLSL program which passes two integer input attributes to the
 *      two-component transform feedback varying vector. Bind first attribute
 *      to attribute index 0. Bind second attribute to attribute index 1.
 *
 *      Create vertex array object.
 *
 *      Prepare vertex buffer object. Setup the buffer with data {1, 0}.
 *      Setup two integer attribute pointers in consecutive way.
 *
 *      Using VertexArrayAttribBinding function, set up binding index 0 to the
 *      attribute index 1. Using VertexArrayAttribBinding function, set up
 *      binding index 1 to the attribute index 0.
 *
 *      Prepare transform feedback buffer object.
 *
 *      Release all data.
 */
class AttributeBindingTest : public deqp::TestCase
{
public:
    /* Public member functions */
    AttributeBindingTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    AttributeBindingTest(const AttributeBindingTest &other);
    AttributeBindingTest &operator=(const AttributeBindingTest &other);

    void PrepareProgram();
    bool PrepareVAO();
    void PrepareXFB();
    bool DrawAndCheck();
    void Clean();

    /* Private member variables. */
    glw::GLuint m_po;
    glw::GLuint m_vao;
    glw::GLuint m_bo_array;
    glw::GLuint m_bo_xfb;

    /* Private static constants. */
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
};
/* AttributeBindingTest class */

class AttributeBindingDivisorTest : public deqp::TestCase
{
public:
    /* Public member functions */
    AttributeBindingDivisorTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    AttributeBindingDivisorTest(const AttributeBindingDivisorTest &other);
    AttributeBindingDivisorTest &operator=(const AttributeBindingDivisorTest &other);

    void PrepareProgram();
    void PrepareVAO();
    void PrepareXFB();
    void Draw(glw::GLuint number_of_points, glw::GLuint number_of_instances);
    bool SetDivisor(glw::GLuint divisor);
    bool CheckXFB(const glw::GLuint count, const glw::GLint expected[], const glw::GLchar *log_message);
    void Clean();

    /* Private member variables. */
    glw::GLuint m_po;
    glw::GLuint m_vao;
    glw::GLuint m_bo_array;
    glw::GLuint m_bo_xfb;

    /* Private static constants. */
    static const glw::GLchar s_vertex_shader[];
    static const glw::GLchar s_fragment_shader[];
};
/* AttributeBindingDivisorTest class */

/* Get Vertex Array
 *
 *      Create vertex array object.
 *
 *      Create buffer object. Set this buffer as an element buffer of the vertex
 *      array object.
 *
 *      Query ELEMENT_ARRAY_BUFFER_BINDING using GetVertexArrayiv. Expect buffer
 *      ID.
 *
 *      Release all objects.
 */
class GetVertexArrayTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetVertexArrayTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    GetVertexArrayTest(const GetVertexArrayTest &other);
    GetVertexArrayTest &operator=(const GetVertexArrayTest &other);
};
/* GetVertexArrayTest class */

/** Get Vertex Array Indexed
 *
 *      Create vertex array object.
 *
 *      Enable attribute indexes 0, 1, 2 and 3.
 *
 *      Create 4 buffer objects. Set these buffer as attribute arrays:
 *          -  attribute 0 with size 1, type BYTE, normalized, stride 0, offset 0,
 *          relative offset 0, binding divisor to 3;
 *          -  integer attribute 1 with size 2, type SHORT, stride 2, offset 2,
 *          relative offset 0, binding divisor to 2;
 *          -  attribute 2 with size 3, type FLOAT, not normalized, stride 0,
 *          offset 8, relative offset 4, binding divisor to 1;
 *          -  attribute 3 with size 4, type UNSIGNED_INT_2_10_10_10_REV, not
 *          normalized, stride 8, offset 4, relative offset 0,
 *          binding divisor to 0.
 *
 *      Query VERTEX_ATTRIB_ARRAY_ENABLED using GetVertexArrayIndexediv. Expect
 *      TRUE for consecutive indexes 0-3 and FALSE for index 4.
 *
 *      Query VERTEX_ATTRIB_ARRAY_SIZE using GetVertexArrayIndexediv. Expect
 *      1, 2, 3, 4 for consecutive indexes.
 *
 *      Query VERTEX_ATTRIB_ARRAY_STRIDE using GetVertexArrayIndexediv. Expect
 *      0, 2, 0, 8 for consecutive indexes.
 *
 *      Query VERTEX_ATTRIB_ARRAY_TYPE using GetVertexArrayIndexediv. Expect
 *      BYTE, SHORT, FLOAT, UNSIGNED_INT_2_10_10_10_REV for consecutive indexes.
 *
 *      Query VERTEX_ATTRIB_ARRAY_NORMALIZED using GetVertexArrayIndexediv.
 *      Expect true, false, false, false for consecutive indexes.
 *
 *      Query VERTEX_ATTRIB_ARRAY_INTEGER using GetVertexArrayIndexediv.
 *      Expect true, true, false, true for consecutive indexes.
 *
 *      Query VERTEX_ATTRIB_ARRAY_LONG using GetVertexArrayIndexediv. Expect
 *      false for consecutive indexes.
 *
 *      Query VERTEX_ATTRIB_ARRAY_DIVISOR using GetVertexArrayIndexediv. Expect
 *      3, 2, 1, 0 for consecutive indexes.
 *
 *      Query VERTEX_ATTRIB_RELATIVE_OFFSET using GetVertexArrayIndexediv.
 *      Expect 0, 0, 4, 0 for consecutive indexes.
 *
 *      Query VERTEX_BINDING_OFFSET using GetVertexArrayIndexed64iv. Expect 0,
 *      2, 8, 4 for consecutive indexes.
 *
 *      Release all objects.
 */
class GetVertexArrayIndexedTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetVertexArrayIndexedTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    GetVertexArrayIndexedTest(const GetVertexArrayIndexedTest &other);
    GetVertexArrayIndexedTest &operator=(const GetVertexArrayIndexedTest &other);

    void PrepareVAO();
    bool Check(const glw::GLenum pname, const glw::GLuint index, const glw::GLint expected);
    bool Check64(const glw::GLenum pname, const glw::GLuint index, const glw::GLint64 expected);

    /* Private member variables. */
    glw::GLuint m_vao;
    glw::GLuint m_bo[4];
};
/* GetVertexArrayIndexedTest class */

/** Vertex Array Defaults
 *
 *      Create empty vertex array object using CreateVertexArrays function.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_ENABLED for all possible
 *      attributes is equal to value FALSE.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_SIZE for all possible
 *      attributes is equal to value 4.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_STRIDE for all possible
 *      attributes is equal to value 0.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_TYPE for all possible
 *      attributes is equal to value FLOAT.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_NORMALIZED for all possible
 *      attributes is equal to value FALSE.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_INTEGER for all possible
 *      attributes is equal to value FALSE.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_LONG for all possible
 *      attributes is equal to value FALSE.
 *
 *      Check that parameter VERTEX_ATTRIB_ARRAY_DIVISOR for all possible
 *      attributes is equal to value 0.
 *
 *      Check that parameter VERTEX_ATTRIB_RELATIVE_OFFSET for all possible
 *      attributes is equal to value 0.
 *
 *      Check that parameter VERTEX_BINDING_OFFSET for all possible attributes
 *      is equal to value 0.
 *
 *      Check that parameter ELEMENT_ARRAY_BUFFER_BINDING is equal to value 0.
 *
 *      Release vertex array object.
 */
class DefaultsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    DefaultsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    DefaultsTest(const DefaultsTest &other);
    DefaultsTest &operator=(const DefaultsTest &other);

    void PrepareVAO();
    bool Check(const glw::GLenum pname, const glw::GLint expected);
    bool CheckIndexed(const glw::GLenum pname, const glw::GLuint index, const glw::GLint expected);
    bool CheckIndexed64(const glw::GLenum pname, const glw::GLuint index, const glw::GLint64 expected);

    /* Private member variables. */
    glw::GLuint m_vao;
};
/* DefaultsTest class */

/** Vertex Array Object Creation Error
 *
 *      Check that INVALID_VALUE is generated if n is negative.
 */
class CreationErrorTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationErrorTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    CreationErrorTest(const CreationErrorTest &other);
    CreationErrorTest &operator=(const CreationErrorTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* CreationErrorTest class */

/** Vertex Array Object Enable Disable Attribute Errors
 *
 *      Check that INVALID_OPERATION is generated by EnableVertexArrayAttrib and
 *      DisableVertexArrayAttrib if vaobj is not the name of an existing vertex
 *      array object.
 *
 *      Check that INVALID_VALUE is generated if index is greater than or equal
 *      to MAX_VERTEX_ATTRIBS.
 */
class EnableDisableAttributeErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    EnableDisableAttributeErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    EnableDisableAttributeErrorsTest(const EnableDisableAttributeErrorsTest &other);
    EnableDisableAttributeErrorsTest &operator=(const EnableDisableAttributeErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* EnableDisableAttributeErrorsTest class */

/** Vertex Array Object Element Buffer Errors
 *
 *      Check that INVALID_OPERATION error is generated by VertexArrayElementBuffer if vaobj is not the name
 *      of an existing vertex array object.
 *
 *      Check that INVALID_OPERATION error is generated by VertexArrayElementBuffer if buffer is not zero or
 *      the name of an existing buffer object.
 */
class ElementBufferErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    ElementBufferErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    ElementBufferErrorsTest(const ElementBufferErrorsTest &other);
    ElementBufferErrorsTest &operator=(const ElementBufferErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* ElementBuffersErrorsTest class */

/** Vertex Array Object Buffer and Buffers Errors
 *
 *      Check that INVALID_OPERATION is generated by VertexArrayVertexBuffer and
 *      VertexArrayVertexBuffers if vaobj is not the name of an existing vertex
 *      array object.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayVertexBuffer if
 *      buffer is not zero or the name of an existing buffer object (as returned
 *      by GenBuffers or CreateBuffers).
 *
 *      Check that INVALID_OPERATION is generated by VertexArrayVertexBuffers if
 *      any value in buffers is not zero or the name of an existing buffer
 *      object.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayVertexBuffer if
 *      bindingindex is greater than or equal to the value of
 *      MAX_VERTEX_ATTRIB_BINDINGS.
 *
 *      Check that INVALID_OPERATION is generated by VertexArrayVertexBuffers if
 *      first+count is greater than the value of MAX_VERTEX_ATTRIB_BINDINGS.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayVertexBuffer if
 *      offset or stride is less than zero, or if stride is greater than the
 *      value of MAX_VERTEX_ATTRIB_STRIDE.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayVertexBuffers if any
 *      value in offsets or strides is negative, or if a value is stride is
 *      greater than the value of MAX_VERTEX_ATTRIB_STRIDE.
 */
class VertexBuffersErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    VertexBuffersErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    VertexBuffersErrorsTest(const VertexBuffersErrorsTest &other);
    VertexBuffersErrorsTest &operator=(const VertexBuffersErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* VertexBuffersErrorsTest class */

/** Vertex Array Object Attribute Format Errors
 *
 *      Check that INVALID_VALUE is generated by VertexArrayAttrib*Format if
 *      attribindex is greater than or equal to the value of MAX_VERTEX_ATTRIBS.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayAttrib*Format if
 *      size is not one of the accepted values.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayAttrib*Format if
 *      relativeoffset is greater than the value of
 *      MAX_VERTEX_ATTRIB_RELATIVE_OFFSET.
 *
 *      Check that INVALID_ENUM is generated by VertexArrayAttrib*Format if type
 *      is not one of the accepted tokens.
 *
 *      Check that INVALID_ENUM is generated by VertexArrayAttrib{IL}Format if
 *      type is UNSIGNED_INT_10F_11F_11F_REV.
 *
 *      Check that INVALID_OPERATION is generated by VertexArrayAttrib*Format if
 *      vaobj is not the name of an existing vertex array object.
 *
 *      Check that INVALID_OPERATION is generated by VertexArrayAttribFormat
 *      under any of the following conditions:
 *       -  size is BGRA and type is not UNSIGNED_BYTE, INT_2_10_10_10_REV or
 *          UNSIGNED_INT_2_10_10_10_REV,
 *       -  type is INT_2_10_10_10_REV or UNSIGNED_INT_2_10_10_10_REV, and size
 *          is neither 4 nor BGRA,
 *       -  type is UNSIGNED_INT_10F_11F_11F_REV and size is not 3,
 *       -  size is BGRA and normalized is FALSE.
 */
class AttributeFormatErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    AttributeFormatErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    AttributeFormatErrorsTest(const AttributeFormatErrorsTest &other);
    AttributeFormatErrorsTest &operator=(const AttributeFormatErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* AttributeFormatErrorsTest class */

/** Vertex Array Attribute Binding Errors
 *
 *      Check that INVALID_OPERATION is generated by VertexArrayAttribBinding if
 *      vaobj is not the name of an existing vertex array object.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayAttribBinding if
 *      attribindex is greater than or equal to the value of MAX_VERTEX_ATTRIBS.
 *
 *      Check that INVALID_VALUE is generated by VertexArrayAttribBinding if
 *      bindingindex is greater than or equal to the value of
 *      MAX_VERTEX_ATTRIB_BINDINGS.
 */
class AttributeBindingErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    AttributeBindingErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    AttributeBindingErrorsTest(const AttributeBindingErrorsTest &other);
    AttributeBindingErrorsTest &operator=(const AttributeBindingErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* AttributeBindingErrorsTest class */

/** Vertex Array Binding Divisor Errors
 *
 *      Check that INVALID_VALUE is generated by VertexArrayBindingDivisor if
 *      bindingindex is greater than or equal to the value of
 *      MAX_VERTEX_ATTRIB_BINDINGS.
 *
 *      Check that INVALID_OPERATION is generated by VertexArrayBindingDivisor
 *      if vaobj is not the name of an existing vertex array object.
 */
class AttributeBindingDivisorErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    AttributeBindingDivisorErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    AttributeBindingDivisorErrorsTest(const AttributeBindingDivisorErrorsTest &other);
    AttributeBindingDivisorErrorsTest &operator=(const AttributeBindingDivisorErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* AttributeBindingDivisorErrorsTest class */

/** Get Vertex Array Errors
 *
 *      Check that INVALID_OPERATION error is generated by GetVertexArrayiv if
 *      vaobj is not the name of an existing vertex array object.
 *
 *      Check that INVALID_ENUM error is generated by GetVertexArrayiv if pname
 *      is not ELEMENT_ARRAY_BUFFER_BINDING.
 */
class GetVertexArrayErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetVertexArrayErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    GetVertexArrayErrorsTest(const GetVertexArrayErrorsTest &other);
    GetVertexArrayErrorsTest &operator=(const GetVertexArrayErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* GetVertexArrayErrorsTest class */

/** Get Vertex Array Indexed Errors
 *
 *      Check that INVALID_OPERATION error is generated by
 *      GetVertexArrayIndexediv and GetVertexArrayIndexed64iv if vaobj is not
 *      the name of an existing vertex array object.
 *
 *      Check that INVALID_VALUE error is generated by GetVertexArrayIndexediv
 *      and GetVertexArrayIndexed64iv if index is greater than or equal to the
 *      value of MAX_VERTEX_ATTRIBS.
 *
 *      Check that INVALID_ENUM error is generated by GetVertexArrayIndexediv if
 *      pname is not one of the valid values:
 *       -  VERTEX_ATTRIB_ARRAY_ENABLED,
 *       -  VERTEX_ATTRIB_ARRAY_SIZE,
 *       -  VERTEX_ATTRIB_ARRAY_STRIDE,
 *       -  VERTEX_ATTRIB_ARRAY_TYPE,
 *       -  VERTEX_ATTRIB_ARRAY_NORMALIZED,
 *       -  VERTEX_ATTRIB_ARRAY_INTEGER,
 *       -  VERTEX_ATTRIB_ARRAY_LONG,
 *       -  VERTEX_ATTRIB_ARRAY_DIVISOR,
 *       -  VERTEX_ATTRIB_RELATIVE_OFFSET.
 *
 *      Check that INVALID_ENUM error is generated by GetVertexArrayIndexed64iv
 *      if pname is not VERTEX_BINDING_OFFSET.
 */
class GetVertexArrayIndexedErrorsTest : public deqp::TestCase
{
public:
    /* Public member functions */
    GetVertexArrayIndexedErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions. */
    GetVertexArrayIndexedErrorsTest(const GetVertexArrayIndexedErrorsTest &other);
    GetVertexArrayIndexedErrorsTest &operator=(const GetVertexArrayIndexedErrorsTest &other);

    bool CheckError(const glw::GLenum expected, const glw::GLchar *log_message);
};
/* GetVertexArrayIndexedErrorsTest class */

namespace Utilities
{
std::string itoa(glw::GLuint i);
std::string replace(const std::string &src, const std::string &key, const std::string &value);
} // namespace Utilities
} // namespace VertexArrays

/* Direct State Access Textures Tests */
namespace Textures
{
/** @class CreationTest
 *
 *  @brief Direct State Access Texture Creation test cases.
 *
 *  Test follows the steps:
 *
 *      Create at least two texture objects using GenTextures function. Check
 *      them without binding, using IsTexture function. Expect FALSE.
 *
 *      Create at least two texture objects using CreateTextures function. Check
 *      them without binding, using IsTexture function. Expect TRUE. Repeat this
 *      step for all targets:
 *          -  TEXTURE_1D,
 *          -  TEXTURE_2D,
 *          -  TEXTURE_3D,
 *          -  TEXTURE_1D_ARRAY,
 *          -  TEXTURE_2D_ARRAY,
 *          -  TEXTURE_RECTANGLE,
 *          -  TEXTURE_CUBE_MAP,
 *          -  TEXTURE_CUBE_MAP_ARRAY,
 *          -  TEXTURE_BUFFER,
 *          -  TEXTURE_2D_MULTISAMPLE and
 *          -  TEXTURE_2D_MULTISAMPLE_ARRAY.
 *
 *      Release objects.
 */
class CreationTest : public deqp::TestCase
{
public:
    /* Public member functions */
    CreationTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private member functions */
    CreationTest(const CreationTest &other);
    CreationTest &operator=(const CreationTest &other);
};
/* CreationTest class */

class Reference
{
public:
    template <typename T, glw::GLint S, bool N>
    static glw::GLenum InternalFormat();

    template <glw::GLint S, bool N>
    static glw::GLenum Format();

    template <typename T>
    static glw::GLenum Type();

    template <typename T, bool N>
    static const T *ReferenceData();

    static glw::GLuint ReferenceDataCount();

    template <typename T>
    static glw::GLuint ReferenceDataSize();

    template <typename T>
    static bool Compare(const T a, const T b);

private:
    static const glw::GLuint s_reference_count = 2 /* 1D */ * 3 /* 2D */ * 4 /* 3D */ * 4 /* components */;
};

/** @class BufferTest
 *
 *  @brief Direct State Access of texture buffers.
 *
 *  @tparam T      Type.
 *  @tparam S      Size.
 *  @tparam N      Is normalized.
 *
 *  Test follows the steps:
 *
 *      Make test for following DSA functions:
 *        -  TextureBuffer,
 *        -  TextureBufferRange
 *       and following texture internal formats:
 *        -  R8,
 *        -  R16,
 *        -  R16F,
 *        -  R32F,
 *        -  R8I,
 *        -  R16I,
 *        -  R32I,
 *        -  R8UI,
 *        -  R16UI,
 *        -  R32UI,
 *        -  RG8,
 *        -  RG16,
 *        -  RG16F,
 *        -  RG32F,
 *        -  RG8I,
 *        -  RG16I,
 *        -  RG32I,
 *        -  RG8UI,
 *        -  RG16UI,
 *        -  RG32UI,
 *        -  RGB32F,
 *        -  RGB32I,
 *        -  RGB32UI,
 *        -  RGBA8,
 *        -  RGBA16,
 *        -  RGBA16F,
 *        -  RGBA32F,
 *        -  RGBA8I,
 *        -  RGBA16I,
 *        -  RGBA32I,
 *        -  RGBA8UI,
 *        -  RGBA16UI,
 *        -  RGBA32UI.
 *
 *          Prepare program which draws textured quad 6 x 1 pixels in size. The
 *          sampled texture shall be buffer texture which linearly store two rows
 *          of three pixels.
 *
 *          Prepare framebuffer 6 x 1 pixels in size.
 *
 *          Prepare texture object with attached buffer object as a storage using
 *          TextureBuffer or TextureBufferRange function. When TextureBufferRange is
 *          being used, test non-zero offset setup. The buffer object shall contain
 *          unique reference values. Texture filtering shall be set to NEAREST.
 *
 *          Using prepared GL objects draw a quad. Fetch framebuffer data using
 *          ReadPixels function. Compare the results with the reference data. Expect
 *          equality.
 *
 *          Release all objects.
 */
template <typename T, glw::GLint S, bool N>
class BufferTest : public deqp::TestCase, Reference
{
public:
    /* Public member functions. */
    BufferTest(deqp::Context &context, const char *name);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    BufferTest(const BufferTest &other);
    BufferTest &operator=(const BufferTest &other);

    /* Private member functions. */
    static glw::GLuint TestReferenceDataCount();

    static glw::GLuint TestReferenceDataSize();

    static const glw::GLchar *FragmentShaderDeclaration();

    bool CreateBufferTexture(bool use_range_version);

    bool Check();

    bool Test(bool use_range_version);

    bool PrepareFramebuffer(const glw::GLenum internal_format);
    void PrepareProgram(const glw::GLchar *variable_declaration);
    void PrepareVertexArray();
    void Draw();
    void CleanBufferTexture();
    void CleanFramebuffer();
    void CleanProgram();
    void CleanErrors();
    void CleanVertexArray();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
    glw::GLuint m_po;
    glw::GLuint m_to;
    glw::GLuint m_bo;
    glw::GLuint m_vao;

    /* Private static constants. */
    static const glw::GLuint s_fbo_size_x = 6;
    static const glw::GLuint s_fbo_size_y = 1;
    static const glw::GLchar *s_vertex_shader;
    static const glw::GLchar *s_fragment_shader_head;
    static const glw::GLchar *s_fragment_shader_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_idecl_highp;
    static const glw::GLchar *s_fragment_shader_udecl_highp;
    static const glw::GLchar *s_fragment_shader_tail;
};

/** @brief Fragment shader part selector.
 *
 *  @return Array of characters with source code.
 */
template <typename T, glw::GLint S, bool N>
const glw::GLchar *BufferTest<T, S, N>::FragmentShaderDeclaration()
{
    if (typeid(T) == typeid(glw::GLbyte))
    {
        return s_fragment_shader_idecl_lowp;
    }

    if (typeid(T) == typeid(glw::GLubyte))
    {
        return N ? s_fragment_shader_fdecl_lowp : s_fragment_shader_udecl_lowp;
    }

    if (typeid(T) == typeid(glw::GLshort))
    {
        return s_fragment_shader_idecl_mediump;
    }

    if (typeid(T) == typeid(glw::GLushort))
    {
        return N ? s_fragment_shader_fdecl_mediump : s_fragment_shader_udecl_mediump;
    }

    if (typeid(T) == typeid(glw::GLint))
    {
        return s_fragment_shader_idecl_highp;
    }

    if (typeid(T) == typeid(glw::GLuint))
    {
        return s_fragment_shader_udecl_highp;
    }

    return s_fragment_shader_fdecl_highp;
}

/* BufferTest class */

/** @class StorageAndSubImageTest
 *
 *  @tparam T      Type.
 *  @tparam S      Size.
 *  @tparam N      Is normalized.
 *  @tparam D      Texture dimension.
 *  @tparam I      Choose between SubImage and Storage tests.
 *
 *      Make test for following DSA storage functions:
 *       -  TextureStorage1D,
 *       -  TextureStorage2D,
 *       -  TextureStorage3D
 *      and DSA SubImage functions:
 *       -  TextureSubImage1D,
 *       -  TextureSubImage2D,
 *       -  TextureSubImage3D.
 *
 *      Test following internal formats:
 *       -  R8,
 *       -  R16,
 *       -  R16F,
 *       -  R32F,
 *       -  R8I,
 *       -  R16I,
 *       -  R32I,
 *       -  R8UI,
 *       -  R16UI,
 *       -  R32UI,
 *       -  RG8,
 *       -  RG16,
 *       -  RG16F,
 *       -  RG32F,
 *       -  RG8I,
 *       -  RG16I,
 *       -  RG32I,
 *       -  RG8UI,
 *       -  RG16UI,
 *       -  RG32UI,
 *       -  RGB32F,
 *       -  RGB32I,
 *       -  RGB32UI,
 *       -  RGBA8,
 *       -  RGBA16,
 *       -  RGBA16F,
 *       -  RGBA32F,
 *       -  RGBA8I,
 *       -  RGBA16I,
 *       -  RGBA32I,
 *       -  RGBA8UI,
 *       -  RGBA16UI,
 *       -  RGBA32UI.
 *
 *      Create texture and prepare its storage with the tested function and
 *      reference data. The texture dimensions shall be 2x3x4 texels in
 *      corresponding directions (if available).
 *
 *      Prepare GLSL program with fragment shader which fetches texture and passes
 *      it to the framebuffer in serialized way.
 *
 *      Prepare framebuffer 24 x 1 pixels in size.
 *
 *      Make draw call with prepared texture and program. Fetch framebuffer and
 *      compare values with the reference data. Expect equality.
 *
 *      Release all objects.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D, bool I>
class StorageAndSubImageTest : public deqp::TestCase, Reference
{
public:
    /* Public member functions. */
    StorageAndSubImageTest(deqp::Context &context, const char *name);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    StorageAndSubImageTest(const StorageAndSubImageTest &other);
    StorageAndSubImageTest &operator=(const StorageAndSubImageTest &other);

    /* Private member functions. */
    static glw::GLuint TestReferenceDataCount();

    static glw::GLuint TestReferenceDataWidth();

    static glw::GLuint TestReferenceDataHeight();

    static glw::GLuint TestReferenceDataDepth();

    static glw::GLuint TestReferenceDataSize();

    static const glw::GLchar *FragmentShaderDeclaration();

    static const glw::GLchar *FragmentShaderTail();

    static glw::GLenum TextureTarget();

    bool TextureSubImage(glw::GLenum target, glw::GLuint texture, glw::GLint level, glw::GLsizei width,
                         glw::GLsizei height, glw::GLsizei depth, glw::GLenum format, glw::GLenum type,
                         const glw::GLvoid *data);

    bool TextureStorage(glw::GLenum target, glw::GLuint texture, glw::GLsizei levels, glw::GLenum internalformat,
                        glw::GLsizei width, glw::GLsizei height, glw::GLsizei depth);

    bool CreateTexture();

    bool Check();

    bool Test();

    void PrepareFramebuffer(const glw::GLenum internal_format);
    void PrepareProgram(const glw::GLchar *variable_declaration, const glw::GLchar *tail);
    void PrepareVertexArray();
    void Draw();
    void CleanTexture();
    void CleanFramebuffer();
    void CleanProgram();
    void CleanErrors();
    void CleanVertexArray();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
    glw::GLuint m_po;
    glw::GLuint m_to;
    glw::GLuint m_vao;

    /* Private static constants. */
    static const glw::GLchar *s_vertex_shader;
    static const glw::GLchar *s_fragment_shader_head;
    static const glw::GLchar *s_fragment_shader_1D_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_1D_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_1D_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_1D_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_1D_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_1D_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_1D_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_1D_idecl_highp;
    static const glw::GLchar *s_fragment_shader_1D_udecl_highp;
    static const glw::GLchar *s_fragment_shader_2D_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_2D_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_2D_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_2D_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_2D_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_2D_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_2D_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_2D_idecl_highp;
    static const glw::GLchar *s_fragment_shader_2D_udecl_highp;
    static const glw::GLchar *s_fragment_shader_3D_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_3D_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_3D_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_3D_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_3D_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_3D_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_3D_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_3D_idecl_highp;
    static const glw::GLchar *s_fragment_shader_3D_udecl_highp;
    static const glw::GLchar *s_fragment_shader_1D_tail;
    static const glw::GLchar *s_fragment_shader_2D_tail;
    static const glw::GLchar *s_fragment_shader_3D_tail;
};
/* StorageAndSubImageTest class */

/** class StorageMultisampleTest
 *
 *      @tparam T      Type.
 *      @tparam S      Size.
 *      @tparam N      Is normalized.
 *      @tparam D      Texture dimension.
 *
 *      Make test for following DSA functions:
 *       -  TextureStorage2DMultisample and
 *       -  TextureStorage3DMultisample.
 *
 *      Test following internal formats:
 *       -  R8,
 *       -  R16,
 *       -  R16F,
 *       -  R32F,
 *       -  R8I,
 *       -  R16I,
 *       -  R32I,
 *       -  R8UI,
 *       -  R16UI,
 *       -  R32UI,
 *       -  RG8,
 *       -  RG16,
 *       -  RG16F,
 *       -  RG32F,
 *       -  RG8I,
 *       -  RG16I,
 *       -  RG32I,
 *       -  RG8UI,
 *       -  RG16UI,
 *       -  RG32UI,
 *       -  RGB32F,
 *       -  RGB32I,
 *       -  RGB32UI,
 *       -  RGBA8,
 *       -  RGBA16,
 *       -  RGBA16F,
 *       -  RGBA32F,
 *       -  RGBA8I,
 *       -  RGBA16I,
 *       -  RGBA32I,
 *       -  RGBA8UI,
 *       -  RGBA16UI,
 *       -  RGBA32UI.
 *
 *      Create multisample texture and prepare its storage with the tested
 *      function. The texture dimensions shall be 2x3x4 texels in corresponding
 *      directions (if available) and two samples per texel.
 *
 *      Prepare two framebuffers. The first one with the multisample texture
 *      as a color attachment with size 2x3 pixels and 4 color attachments
 *      (layers). The second one with non-multisample renderbuffer storage
 *      similar in size.
 *
 *      Prepare GLSL program which draws explicitly reference data to
 *      multisample texture framebuffer.
 *
 *      Use program to draw the reference data into multisample texture.
 *
 *      Prepare second GLSL program with fragment shader which passes samples of
 *      the input texture to the separate framebuffer pixels.
 *
 *      Use the second program to draw the multisample texture into
 *      renderbuffer.
 *
 *      Fetch framebuffer data and compare with the reference values. Expect
 *      equality.
 *
 *      Release all objects.
 */
template <typename T, glw::GLint S, bool N, glw::GLuint D>
class StorageMultisampleTest : public deqp::TestCase, Reference
{
public:
    /* Public member functions. */
    StorageMultisampleTest(deqp::Context &context, const char *name);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    StorageMultisampleTest(const StorageMultisampleTest &other);
    StorageMultisampleTest &operator=(const StorageMultisampleTest &other);

    /* Private member functions. */
    static glw::GLuint TestReferenceDataCount();

    static glw::GLuint TestReferenceDataWidth();

    static glw::GLuint TestReferenceDataHeight();

    static glw::GLuint TestReferenceDataDepth();

    static glw::GLuint TestReferenceDataSize();

    static const glw::GLchar *FragmentShaderDeclarationMultisample();

    static const glw::GLchar *FragmentShaderDeclarationAuxiliary();

    static const glw::GLchar *FragmentShaderTail();

    static glw::GLenum InputTextureTarget();

    static glw::GLenum MultisampleTextureTarget();

    void InputTextureImage(const glw::GLenum internal_format, const glw::GLuint width, const glw::GLuint height,
                           const glw::GLuint depth, const glw::GLenum format, const glw::GLenum type,
                           const glw::GLvoid *data);

    void CreateInputTexture();

    bool Check();

    bool Test();

    bool PrepareFramebufferMultisample(const glw::GLenum internal_format);

    void PrepareFramebufferAuxiliary(const glw::GLenum internal_format);

    glw::GLuint PrepareProgram(const glw::GLchar *variable_declaration, const glw::GLchar *tail);
    void PrepareVertexArray();

    void Draw();

    void CleanInputTexture();
    void CleanAuxiliaryTexture();
    void CleanFramebuffers();
    void CleanPrograms();
    void CleanErrors();
    void CleanVertexArray();

    /* Private member variables. */
    glw::GLuint m_fbo_ms;
    glw::GLuint m_fbo_aux;
    glw::GLuint m_to_ms;
    glw::GLuint m_po_ms;
    glw::GLuint m_po_aux;
    glw::GLuint m_to;
    glw::GLuint m_to_aux;
    glw::GLuint m_vao;

    /* Private static constants. */
    static const glw::GLchar *s_vertex_shader;
    static const glw::GLchar *s_fragment_shader_head;
    static const glw::GLchar *s_fragment_shader_ms_2D_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_ms_2D_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_ms_2D_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_ms_2D_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_ms_2D_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_ms_2D_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_ms_2D_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_ms_2D_idecl_highp;
    static const glw::GLchar *s_fragment_shader_ms_2D_udecl_highp;

    static const glw::GLchar *s_fragment_shader_ms_3D_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_ms_3D_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_ms_3D_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_ms_3D_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_ms_3D_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_ms_3D_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_ms_3D_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_ms_3D_idecl_highp;
    static const glw::GLchar *s_fragment_shader_ms_3D_udecl_highp;

    static const glw::GLchar *s_fragment_shader_aux_2D_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_aux_2D_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_aux_2D_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_aux_2D_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_aux_2D_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_aux_2D_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_aux_2D_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_aux_2D_idecl_highp;
    static const glw::GLchar *s_fragment_shader_aux_2D_udecl_highp;

    static const glw::GLchar *s_fragment_shader_aux_3D_fdecl_lowp;
    static const glw::GLchar *s_fragment_shader_aux_3D_idecl_lowp;
    static const glw::GLchar *s_fragment_shader_aux_3D_udecl_lowp;
    static const glw::GLchar *s_fragment_shader_aux_3D_fdecl_mediump;
    static const glw::GLchar *s_fragment_shader_aux_3D_idecl_mediump;
    static const glw::GLchar *s_fragment_shader_aux_3D_udecl_mediump;
    static const glw::GLchar *s_fragment_shader_aux_3D_fdecl_highp;
    static const glw::GLchar *s_fragment_shader_aux_3D_idecl_highp;
    static const glw::GLchar *s_fragment_shader_aux_3D_udecl_highp;
    static const glw::GLchar *s_fragment_shader_tail_2D;
    static const glw::GLchar *s_fragment_shader_tail_3D;
};
/* StorageMultisampleTest class */

/**  @class CompressedSubImage
 *
 *    Make test for following DSA functions:
 *        -  CompressedTextureSubImage1D,
 *        -  CompressedTextureSubImage2D,
 *        -  CompressedTextureSubImage3D.
 *
 *    Make test for following uncompressed internal formats:
 *        -  R8,
 *        -  R8_SNORM,
 *        -  R16,
 *        -  R16_SNORM,
 *        -  RG8,
 *        -  RG8_SNORM,
 *        -  RG16,
 *        -  RG16_SNORM,
 *        -  R3_G3_B2,
 *        -  RGB4,
 *        -  RGB5,
 *        -  RGB8,
 *        -  RGB8_SNORM,
 *        -  RGB10,
 *        -  RGB12,
 *        -  RGB16_SNORM,
 *        -  RGBA2,
 *        -  RGBA4,
 *        -  RGB5_A1,
 *        -  RGBA8,
 *        -  RGBA8_SNORM,
 *        -  RGB10_A2,
 *        -  RGB10_A2UI,
 *        -  RGBA12,
 *        -  RGBA16,
 *        -  SRGB8,
 *        -  SRGB8_ALPHA8,
 *        -  R16F,
 *        -  RG16F,
 *        -  RGB16F,
 *        -  RGBA16F,
 *        -  R32F,
 *        -  RG32F,
 *        -  RGB32F,
 *        -  RGBA32F,
 *        -  R11F_G11F_B10F,
 *        -  RGB9_E5,
 *        -  R8I,
 *        -  R8UI,
 *        -  R16I,
 *        -  R16UI,
 *        -  R32I,
 *        -  R32UI,
 *        -  RG8I,
 *        -  RG8UI,
 *        -  RG16I,
 *        -  RG16UI,
 *        -  RG32I,
 *        -  RG32UI,
 *        -  RGB8I,
 *        -  RGB8UI,
 *        -  RGB16I,
 *        -  RGB16UI,
 *        -  RGB32I,
 *        -  RGB32UI,
 *        -  RGBA8I,
 *        -  RGBA8UI,
 *        -  RGBA16I,
 *        -  RGBA16UI,
 *        -  RGBA32I,
 *        -  RGBA32UI.
 *    and compressed internal formats:
 *        -  COMPRESSED_RGBA8_ETC2_EAC.
 *
 *    Create texture and setup its storage and data using tested function with
 *    size 2x3 pixels.
 *
 *    Prepare framebuffer with renderbuffer color attachment with floating
 *    point internal format and with size 2x3 pixels
 *
 *    Prepare GLSL program with fragment shader which passes input texture to
 *    the framebuffer.
 *
 *    Draw a full screen quad with the prepared texture, program and
 *    framebuffer. Read the framebuffer content. Compare framebuffer's values
 *    with the reference values. Take normalization and precision into
 *    account. Expect equality.
 *
 *    Release all objects.
 */
class CompressedSubImageTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    CompressedSubImageTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    CompressedSubImageTest(const CompressedSubImageTest &other);
    CompressedSubImageTest &operator=(const CompressedSubImageTest &other);

    void CreateTextures(glw::GLenum target);

    template <glw::GLuint D>
    glw::GLenum TextureTarget();

    template <glw::GLuint D>
    bool TextureImage(glw::GLint internalformat);

    template <glw::GLuint D>
    void CompressedTexImage(glw::GLint internalformat);

    template <glw::GLuint D>
    bool CompressedTextureSubImage(glw::GLint internalformat);

    template <glw::GLuint D>
    bool PrepareReferenceData(glw::GLenum internalformat);

    template <glw::GLuint D>
    void PrepareStorage(glw::GLenum internalformat);

    template <glw::GLuint D>
    void PrepareCompressedStorage(glw::GLenum internalformat);

    template <glw::GLuint D>
    bool CheckData(glw::GLenum internalformat);
    void CleanAll();
    std::string DataToString(glw::GLuint count, const glw::GLubyte data[]);

    template <glw::GLuint D>
    bool Test(glw::GLenum internalformat, bool can_be_unsupported);

    /* Private member variables. */
    glw::GLuint m_to;
    glw::GLuint m_to_aux;
    glw::GLubyte *m_compressed_texture_data;
    glw::GLubyte *m_reference;
    glw::GLubyte *m_result;
    glw::GLuint m_reference_size;
    glw::GLuint m_reference_internalformat;

    /* Private static constants. */
    static const glw::GLubyte s_texture_data[];
    static const glw::GLuint s_texture_width;
    static const glw::GLuint s_texture_height;
    static const glw::GLuint s_texture_depth;
    static const glw::GLuint s_block_count;
    static const glw::GLuint s_block_2d_size_x;
    static const glw::GLuint s_block_2d_size_y;
    static const glw::GLuint s_block_3d_size;
};
/* CompressedSubImageTest class */

/** @class CopyTest
 *
 *      Make test for following DSA functions:
 *       -  CopyTextureSubImage1D,
 *       -  CopyTextureSubImage2D and
 *       -  CopyTextureSubImage3D.
 *
 *      Prepare two textures 2x3x4 texels in size for corresponding directions
 *      (if available). Setup the first one with reference data.
 *
 *      Prepare framebuffer with the first texture attached to the a color
 *      attachment point. Bind the framebuffer.
 *
 *      Copy framebuffer content to the texture using tested function. The
 *      images shall be copied in ranges, two per direction (to test offsets,
 *      positions and size variables). For 3D textures copy each layer
 *      substituting the framebuffer attachment.
 *
 *      After the copy fetch texture data and compare it with the reference
 *      values. Expect equality.
 *
 *      Release all objects.
 */
class CopyTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    CopyTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    CopyTest(const CopyTest &other);
    CopyTest &operator=(const CopyTest &other);

    /* Private member functions. */
    template <glw::GLuint D>
    glw::GLenum TextureTarget();

    bool CopyTextureSubImage1DAndCheckErrors(glw::GLuint texture, glw::GLint level, glw::GLint xoffset, glw::GLint x,
                                             glw::GLint y, glw::GLsizei width);
    bool CopyTextureSubImage2DAndCheckErrors(glw::GLuint texture, glw::GLint level, glw::GLint xoffset,
                                             glw::GLint yoffset, glw::GLint x, glw::GLint y, glw::GLsizei width,
                                             glw::GLsizei height);
    bool CopyTextureSubImage3DAndCheckErrors(glw::GLuint texture, glw::GLint level, glw::GLint xoffset,
                                             glw::GLint yoffset, glw::GLint zoffset, glw::GLint x, glw::GLint y,
                                             glw::GLsizei width, glw::GLsizei height);

    template <glw::GLuint D>
    void CreateSourceTexture();

    template <glw::GLuint D>
    void CreateDestinationTexture();

    template <glw::GLuint D>
    void CreateSourceFramebuffer();

    template <glw::GLuint D>
    void CreateAll();

    template <glw::GLuint D>
    bool Test();

    bool CheckData(glw::GLenum target, glw::GLuint size);
    std::string DataToString(glw::GLuint count, const glw::GLubyte data[]);
    void CleanAll();

    /* Private member variables. */
    glw::GLuint m_fbo;
    glw::GLuint m_to_src;
    glw::GLuint m_to_dst;
    glw::GLubyte *m_result;

    /* Private static constants. */
    static const glw::GLubyte s_texture_data[];
    static const glw::GLuint s_texture_width;
    static const glw::GLuint s_texture_height;
    static const glw::GLuint s_texture_depth;
};
/* CopyTest class */

/** @class GetSetParameterTest
 *
 *  Do following:
 *      Prepare texture object.
 *
 *      Prepare the following test case.
 *
 *          Prepare test case which sets a parameter to the desired value using
 *          one of the following functions (depending on the parameter type):
 *           -  TextureParameterf,
 *           -  TextureParameterfv,
 *           -  TextureParameteri,
 *           -  TextureParameterIiv,
 *           -  TextureParameterIuiv,
 *           -  TextureParameteriv.
 *
 *          Read back the texture parameter using one of the DSA-like functions
 *           -  GetTextureParameterfv,
 *           -  GetTextureParameteriv,
 *           -  GetTextureParameterIiv,
 *           -  GetTextureParameterIuiv.
 *          Expect equality.
 *
 *      Run the test case for following parameters and values:
 *       -  parameter DEPTH_STENCIL_TEXTURE_MODE with value DEPTH_COMPONENT;
 *       -  parameter TEXTURE_BASE_LEVEL with value 2;
 *       -  parameter TEXTURE_BORDER_COLOR with value {0.25, 0.5, 0.75, 1.0}
 *       -  parameter TEXTURE_COMPARE_FUNC with value LEQUAL;
 *       -  parameter TEXTURE_COMPARE_MODE with value COMPARE_REF_TO_TEXTURE;
 *       -  parameter TEXTURE_LOD_BIAS with value -2.0 (which is
 *          minimum required implementation maximum value);
 *       -  parameter TEXTURE_MIN_FILTER with value LINEAR_MIPMAP_NEAREST;
 *       -  parameter TEXTURE_MAG_FILTER with value NEAREST;
 *       -  parameter TEXTURE_MIN_LOD with value -100;
 *       -  parameter TEXTURE_MAX_LOD with value 100;
 *       -  parameter TEXTURE_MAX_LEVEL with value 100;
 *       -  parameter TEXTURE_SWIZZLE_R with value BLUE;
 *       -  parameter TEXTURE_SWIZZLE_G with value ALPHA;
 *       -  parameter TEXTURE_SWIZZLE_B with value RED;
 *       -  parameter TEXTURE_SWIZZLE_A with value GREEN;
 *       -  parameter TEXTURE_SWIZZLE_RGBA with value { ZERO, ONE, ZERO, ONE };
 *       -  parameter TEXTURE_WRAP_S with value MIRROR_CLAMP_TO_EDGE;
 *       -  parameter TEXTURE_WRAP_T with value CLAMP_TO_EDGE;
 *       -  parameter TEXTURE_WRAP_R with value CLAMP_TO_EDGE.
 *
 *      Release the texture object.
 */
class GetSetParameterTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    GetSetParameterTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    GetSetParameterTest(const GetSetParameterTest &other);
    GetSetParameterTest &operator=(const GetSetParameterTest &other);

    bool CheckErrorAndLog(const glw::GLchar *fname, glw::GLenum pname);
    bool CompareAndLog(glw::GLint value_src, glw::GLint value_dst, glw::GLenum pname);
    bool CompareAndLog(glw::GLuint value_src, glw::GLuint value_dst, glw::GLenum pname);
    bool CompareAndLog(glw::GLfloat value_src, glw::GLfloat value_dst, glw::GLenum pname);
    bool CompareAndLog(glw::GLfloat value_src[4], glw::GLfloat value_dst[4], glw::GLenum pname);
    bool CompareAndLog(glw::GLint value_src[4], glw::GLint value_dst[4], glw::GLenum pname);
    bool CompareAndLog(glw::GLuint value_src[4], glw::GLuint value_dst[4], glw::GLenum pname);
};
/* GetSetParameterTest class */

/** @class DefaultsTest
 *
 *      Create texture object with CreateTextures. Do not bind it.
 *
 *      Using one of the functions
 *       -  GetTextureParameterfv,
 *       -  GetTextureParameteriv,
 *       -  GetTextureParameterIiv,
 *       -  GetTextureParameterIuiv
 *      check that initial object parameter values are set to the following
 *      defaults:
 *       -  for parameter DEPTH_STENCIL_TEXTURE_MODE initial value is
 *          DEPTH_COMPONENT;
 *       -  for parameter TEXTURE_BASE_LEVEL initial value is 0;
 *       -  for parameter TEXTURE_BORDER_COLOR initial value is {0.0, 0.0, 0.0,
 *          0.0};
 *       -  for parameter TEXTURE_COMPARE_FUNC initial value is LEQUAL;
 *       -  for parameter TEXTURE_COMPARE_MODE initial value is NONE;
 *       -  for parameter TEXTURE_LOD_BIAS initial value is 0.0;
 *       -  for parameter TEXTURE_MIN_FILTER initial value is
 *          NEAREST_MIPMAP_LINEAR;
 *       -  for parameter TEXTURE_MAG_FILTER initial value is LINEAR;
 *       -  for parameter TEXTURE_MIN_LOD initial value is -1000;
 *       -  for parameter TEXTURE_MAX_LOD initial value is 1000;
 *       -  for parameter TEXTURE_MAX_LEVEL initial value is 1000;
 *       -  for parameter TEXTURE_SWIZZLE_R initial value is RED;
 *       -  for parameter TEXTURE_SWIZZLE_G initial value is GREEN;
 *       -  for parameter TEXTURE_SWIZZLE_B initial value is BLUE;
 *       -  for parameter TEXTURE_SWIZZLE_A initial value is ALPHA;
 *       -  for parameter TEXTURE_WRAP_S initial value is REPEAT;
 *       -  for parameter TEXTURE_WRAP_T initial value is REPEAT;
 *       -  for parameter TEXTURE_WRAP_R initial value is REPEAT.
 */
class DefaultsTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    DefaultsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    DefaultsTest(const DefaultsTest &other);
    DefaultsTest &operator=(const DefaultsTest &other);

    bool CompareAndLog(glw::GLint value_ref, glw::GLint value_dst, glw::GLenum pname);
    bool CompareAndLog(glw::GLuint value_ref, glw::GLuint value_dst, glw::GLenum pname);
    bool CompareAndLog(glw::GLfloat value_ref, glw::GLfloat value_dst, glw::GLenum pname);
    bool CompareAndLog(glw::GLfloat value_ref[4], glw::GLfloat value_dst[4], glw::GLenum pname);
    bool CompareAndLog(glw::GLint value_ref[4], glw::GLint value_dst[4], glw::GLenum pname);
    bool CompareAndLog(glw::GLuint value_ref[4], glw::GLuint value_dst[4], glw::GLenum pname);
};
/* DefaultsTest class */

/** @class GenerateMipmapTest
 *
 *      Create one dimensional texture. Setup its image data with successive
 *      numbers {0..255} stored as red color.
 *
 *      Generate mipmaps for the texture using GenerateTextureMipmap function.
 *
 *      Download each of the generated mipmap levels. Check that each of the
 *      mipmaps contains series of not decreasing values.
 *
 *      Release texture object.
 */
class GenerateMipmapTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    GenerateMipmapTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    GenerateMipmapTest(const GenerateMipmapTest &other);
    GenerateMipmapTest &operator=(const GenerateMipmapTest &other);

    /* Private static constants. */
    static const glw::GLubyte s_texture_data[];
    static const glw::GLuint s_texture_width;
    static const glw::GLuint s_texture_width_log;
};
/* GenerateMipmapTest class */

/** @class BindUnitTest
 *
 *      Create four 2D textures, filled with 2x3 texels of reference data in RED
 *      format and R8 internal format.
 *
 *      Create framebuffer 2x3 pixels of size with the same internal format as
 *      textures but RGBA format.
 *
 *      Bind each texture to the separate unit using BindTextureUnit function.
 *
 *      Prepare GLSL program which draws full screen quad. A fragment shader of
 *      the program shall pass each of the four input texture red values into
 *      separate RGBA channel of the output framebuffer.
 *
 *      Make a draw call with prepared objects.
 *
 *      Fetch framebuffer data. Expect interleaved reference data.
 *
 *      Release all objects.
 */
class BindUnitTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    BindUnitTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    BindUnitTest(const BindUnitTest &other);
    BindUnitTest &operator=(const BindUnitTest &other);

    void CreateProgram();
    void CreateTextures();
    void CreateFrambuffer();
    void CreateVertexArray();
    bool Draw();
    bool Check();
    void CleanAll();
    std::string DataToString(glw::GLuint count, const glw::GLubyte data[]);

    /* Private member variables. */
    glw::GLuint m_po;
    glw::GLuint m_to[4];
    glw::GLuint m_fbo;
    glw::GLuint m_rbo;
    glw::GLuint m_vao;
    glw::GLubyte *m_result;

    /* Private static constants. */
    static const glw::GLubyte s_texture_data_r[];
    static const glw::GLubyte s_texture_data_g[];
    static const glw::GLubyte s_texture_data_b[];
    static const glw::GLubyte s_texture_data_a[];
    static const glw::GLubyte s_texture_data_rgba[];
    static const glw::GLuint s_texture_width;
    static const glw::GLuint s_texture_height;
    static const glw::GLuint s_texture_count_rgba;
    static const glw::GLchar *s_vertex_shader;
    static const glw::GLchar *s_fragment_shader;
    static const glw::GLchar *s_fragment_shader_samplers[4];
};
/* GenerateMipmapTest class */

/** @class GetImageTest
 *
 *          Make test for following DSA functions:
 *       -  GetTextureImage,
 *       -  GetCompressedTextureImage.
 *
 *      Create two 2D textures, one with compressed reference image, one with
 *      uncompressed reference image.
 *
 *      Fetch textures with corresponding test functions. Compare fetched values
 *      with the reference data. Expect equality.
 *
 *      Release textures.
 */
class GetImageTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    GetImageTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    GetImageTest(const GetImageTest &other);
    GetImageTest &operator=(const GetImageTest &other);

    std::string DataToString(glw::GLuint count, const glw::GLubyte data[]);

    /* Private static constants. */
    static const glw::GLubyte s_texture_data[];
    static const glw::GLubyte s_texture_data_compressed[];
    static const glw::GLuint s_texture_width;
    static const glw::GLuint s_texture_height;
    static const glw::GLuint s_texture_size;
    static const glw::GLuint s_texture_size_compressed;
    static const glw::GLuint s_texture_count;
    static const glw::GLuint s_texture_count_compressed;
};
/* GetImageTest class */

/** @class GetLevelParameterTest
 *
 *      Make test for following DSA functions:
 *          -  GetTextureLevelParameterfv,
 *          -  GetTextureLevelParameteriv.
 *
 *      Create 3D texture with two levels of detail.
 *
 *      Fetch following parameters with test functions:
 *       -  TEXTURE_WIDTH,
 *       -  TEXTURE_HEIGHT,
 *       -  TEXTURE_DEPTH,
 *       -  TEXTURE_INTERNAL_FORMAT,
 *       -  TEXTURE_RED_TYPE,
 *       -  TEXTURE_GREEN_TYPE,
 *       -  TEXTURE_BLUE_TYPE,
 *       -  TEXTURE_ALPHA_TYPE,
 *       -  TEXTURE_DEPTH_TYPE,
 *       -  TEXTURE_RED_SIZE,
 *       -  TEXTURE_GREEN_SIZE,
 *       -  TEXTURE_BLUE_SIZE,
 *       -  TEXTURE_ALPHA_SIZE,
 *       -  TEXTURE_DEPTH_SIZE and
 *       -  TEXTURE_COMPRESSED
 *      and compare values with expected set.
 *
 *      Release texture.
 */
class GetLevelParameterTest : public deqp::TestCase
{
public:
    /* Public member functions. */
    GetLevelParameterTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    GetLevelParameterTest(const GetLevelParameterTest &other);
    GetLevelParameterTest &operator=(const GetLevelParameterTest &other);

    /* Private static constants. */
    static const glw::GLubyte s_texture_data[];
    static const glw::GLuint s_texture_width;
    static const glw::GLuint s_texture_height;
    static const glw::GLuint s_texture_depth;
};
/* GetLevelParameterTest class */

/** @class ErrorsUtilities
 *
 *      This class contain utility methods for all negative tests.
 */
class ErrorsUtilities
{
public:
    bool CheckErrorAndLog(deqp::Context &context, glw::GLuint expected_error, const glw::GLchar *function_name,
                          const glw::GLchar *log);
};
/* ErrorsUtilities  */

/** @class CreationErrorsTest
 *
 *      Check that INVALID_ENUM is generated if target is not one of the
 *      allowable values.
 *
 *      Check that INVALID_VALUE is generated if n is negative.
 */
class CreationErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    CreationErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    CreationErrorsTest(const CreationErrorsTest &other);
    CreationErrorsTest &operator=(const CreationErrorsTest &other);

    glw::GLenum NotATarget();
};
/* CreationErrorsTest class */

/** @class BufferErrorsTest
 *
 *      Check that INVALID_OPERATION is generated by glTextureBuffer if texture
 *      is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by glTextureBuffer if the effective
 *      target of texture is not TEXTURE_BUFFER.
 *
 *      Check that INVALID_ENUM is generated if internalformat is not one of the
 *      sized internal formats described above.
 *
 *      Check that INVALID_OPERATION is generated if buffer is not zero and is
 *      not the name of an existing buffer object.
 */
class BufferErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    BufferErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    BufferErrorsTest(const BufferErrorsTest &other);
    BufferErrorsTest &operator=(const BufferErrorsTest &other);
};
/* BufferErrorsTest class */

/** @class BufferRangeErrorsTest
 *
 *      Check that INVALID_OPERATION is generated by TextureBufferRange if
 *      texture is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by TextureBufferRange if the
 *      effective target of texture is not TEXTURE_BUFFER.
 *
 *      Check that INVALID_ENUM is generated by TextureBufferRange if
 *      internalformat is not one of the sized internal formats described above.
 *
 *      Check that INVALID_OPERATION is generated by TextureBufferRange if
 *      buffer is not zero and is not the name of an existing buffer object.
 *
 *      Check that INVALID_VALUE is generated by TextureBufferRange if offset
 *      is negative, if size is less than or equal to zero, or if offset + size
 *      is greater than the value of BUFFER_SIZE for buffer.
 *
 *      Check that INVALID_VALUE is generated by TextureBufferRange if offset is
 *      not an integer multiple of the value of TEXTURE_BUFFER_OFFSET_ALIGNMENT.
 */
class BufferRangeErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    BufferRangeErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    BufferRangeErrorsTest(const BufferRangeErrorsTest &other);
    BufferRangeErrorsTest &operator=(const BufferRangeErrorsTest &other);
};
/* BufferErrorsTest class */

/** @class StorageErrorsTest
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage1D if texture
 *      is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage1D if
 *      internalformat is not a valid sized internal format.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage1D if target or
 *      the effective target of texture is not one of the accepted targets
 *      described above.
 *
 *      Check that INVALID_VALUE is generated by TextureStorage1D if width or
 *      levels are less than 1.
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage1D if levels
 *      is greater than log2(width)+1.
 *
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage2D if
 *      texture is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage2D if
 *      internalformat is not a valid sized internal format.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage2D if target or
 *      the effective target of texture is not one of the accepted targets
 *      described above.
 *
 *      Check that INVALID_VALUE is generated by TextureStorage2D if width,
 *      height or levels are less than 1.
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage2D if target
 *      is TEXTURE_1D_ARRAY or PROXY_TEXTURE_1D_ARRAY and levels is greater than
 *      log2(width)+1.
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage2D if target
 *      is not TEXTURE_1D_ARRAY or PROXY_TEXTURE_1D_ARRAY and levels is greater
 *      than log2(max(width, height))+1.
 *
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage2DMultisample
 *      if texture is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage2DMultisample if
 *      internalformat is not a valid color-renderable, depth-renderable or
 *      stencil-renderable format.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage2DMultisample if
 *      target or the effective target of texture is not one of the accepted
 *      targets described above.
 *
 *      Check that INVALID_VALUE is generated by TextureStorage2DMultisample if
 *      width or height are less than 1 or greater than the value of
 *      MAX_TEXTURE_SIZE.
 *
 *
 *      Check that INVALID_VALUE is generated by TextureStorage2DMultisample if
 *      samples is greater than the value of MAX_SAMPLES.
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage2DMultisample
 *      if the value of TEXTURE_IMMUTABLE_FORMAT for the texture bound to target
 *      is not FALSE.
 *
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage3D if texture
 *      is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage3D if
 *      internalformat is not a valid sized internal format.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage3D if target or
 *      the effective target of texture is not one of the accepted targets
 *      described above.
 *
 *      Check that INVALID_VALUE is generated by TextureStorage3D if width,
 *      height, depth or levels are less than 1.
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage3D if target
 *      is TEXTURE_3D or PROXY_TEXTURE_3D and levels is greater than
 *      log2(max(width, height, depth))+1.
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage3D if target
 *      is TEXTURE_2D_ARRAY, PROXY_TEXTURE_2D_ARRAY, TEXURE_CUBE_ARRAY,
 *      or PROXY_TEXTURE_CUBE_MAP_ARRAY and levels is greater than
 *      log2(max(width, height))+1.
 *
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage3DMultisample
 *      if texture is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage3DMultisample if
 *      internalformat is not a valid color-renderable, depth-renderable or
 *      stencil-renderable format.
 *
 *      Check that INVALID_ENUM is generated by TextureStorage3DMultisample if
 *      target or the effective target of texture is not one of the accepted
 *      targets described above.
 *
 *      Check that INVALID_VALUE is generated by TextureStorage3DMultisample if
 *      width or height are less than 1 or greater than the value of
 *      MAX_TEXTURE_SIZE.
 *
 *      Check that INVALID_VALUE is generated by TextureStorage3DMultisample if
 *      depth is less than 1 or greater than the value of
 *      MAX_ARRAY_TEXTURE_LAYERS.
 *
 *      Check that INVALID_VALUE is generated by TextureStorage3DMultisample if
 *      samples is greater than the value of MAX_SAMPLES.
 *
 *      Check that INVALID_OPERATION is generated by TextureStorage3DMultisample
 *      if the value of TEXTURE_IMMUTABLE_FORMAT for the texture bound to
 *      target is not FALSE.
 */
class StorageErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    StorageErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    StorageErrorsTest(const StorageErrorsTest &other);
    StorageErrorsTest &operator=(const StorageErrorsTest &other);

    glw::GLuint m_to_1D;
    glw::GLuint m_to_1D_array;
    glw::GLuint m_to_2D;
    glw::GLuint m_to_2D_array;
    glw::GLuint m_to_3D;
    glw::GLuint m_to_2D_ms;
    glw::GLuint m_to_2D_ms_immutable;
    glw::GLuint m_to_3D_ms;
    glw::GLuint m_to_3D_ms_immutable;
    glw::GLuint m_to_invalid;
    glw::GLuint m_internalformat_invalid;
    glw::GLint m_max_texture_size;
    glw::GLint m_max_samples;
    glw::GLint m_max_array_texture_layers;

    void Prepare();
    bool Test1D();
    bool Test2D();
    bool Test3D();
    bool Test2DMultisample();
    bool Test3DMultisample();
    void Clean();
};
/* StorageErrorsTest class */

/** @class SubImageErrorsTest
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage1D if
 *          texture is not the name of an existing texture object.
 *
 *          Check that INVALID_ENUM is generated by TextureSubImage1D if format is
 *          not an accepted format constant.
 *
 *          Check that INVALID_ENUM is generated by TextureSubImage1D if type is not
 *          a type constant.
 *
 *          Check that INVALID_VALUE is generated by TextureSubImage1D if level is
 *          less than 0.
 *
 *          Check that INVALID_VALUE may be generated by TextureSubImage1D if level
 *          is greater than log2 max, where max is the returned value of
 *          MAX_TEXTURE_SIZE.
 *
 *          Check that INVALID_VALUE is generated by TextureSubImage1D if
 *          xoffset<-b, or if (xoffset+width)>(w-b), where w is the TEXTURE_WIDTH,
 *          and b is the width of the TEXTURE_BORDER of the texture image being
 *          modified. Note that w includes twice the border width.
 *          Check that INVALID_VALUE is generated by TextureSubImage1D if width is
 *          less than 0.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage1D if type
 *          is one of UNSIGNED_BYTE_3_3_2, UNSIGNED_BYTE_2_3_3_REV,
 *          UNSIGNED_SHORT_5_6_5, or UNSIGNED_SHORT_5_6_5_REV and format is not RGB.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage1D if type
 *          is one of UNSIGNED_SHORT_4_4_4_4, UNSIGNED_SHORT_4_4_4_4_REV,
 *          UNSIGNED_SHORT_5_5_5_1, UNSIGNED_SHORT_1_5_5_5_REV,
 *          UNSIGNED_INT_8_8_8_8, UNSIGNED_INT_8_8_8_8_REV, UNSIGNED_INT_10_10_10_2,
 *          or UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage1D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and the buffer object's data store is currently mapped.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage1D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and the data would be unpacked from the buffer object such that the
 *          memory reads required would exceed the data store size.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage1D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and pixels is not evenly divisible into the number of bytes needed to
 *          store in memory a datum indicated by type.
 *
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage2D if
 *          texture is not the name of an existing texture object.
 *
 *          Check that INVALID_ENUM is generated by TextureSubImage2D if format is
 *          not an accepted format constant.
 *
 *          Check that INVALID_ENUM is generated if type is not a type constant.
 *
 *          Check that INVALID_VALUE is generated by TextureSubImage2D if level is
 *          less than 0.
 *
 *          Check that INVALID_VALUE may be generated by TextureSubImage2D if level
 *          is greater than log2 max, where max is the returned value of
 *          MAX_TEXTURE_SIZE.
 *          Check that INVALID_VALUE is generated by TextureSubImage2D if
 *          xoffset<-b, (xoffset+width)>(w-b), yoffset<-b, or
 *          (yoffset+height)>(h-b), where w is the TEXTURE_WIDTH, h is the
 *          TEXTURE_HEIGHT, and b is the border width of the texture image being
 *          modified. Note that w and h include twice the border width.
 *          Check that INVALID_VALUE is generated by TextureSubImage2D if width or
 *          height is less than 0.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage2D if type
 *          is one of UNSIGNED_BYTE_3_3_2, UNSIGNED_BYTE_2_3_3_REV,
 *          UNSIGNED_SHORT_5_6_5, or UNSIGNED_SHORT_5_6_5_REV and format is not RGB.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage2D if type
 *          is one of UNSIGNED_SHORT_4_4_4_4, UNSIGNED_SHORT_4_4_4_4_REV,
 *          UNSIGNED_SHORT_5_5_5_1, UNSIGNED_SHORT_1_5_5_5_REV, UNSIGNED_INT_8_8_8_8,
 *          UNSIGNED_INT_8_8_8_8_REV, UNSIGNED_INT_10_10_10_2, or
 *          UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA
 *          nor BGRA.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage2D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and the buffer object's data store is currently mapped.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage2D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and the data would be unpacked from the buffer object such that the
 *          memory reads required would exceed the data store size.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage2D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and pixels is not evenly divisible into the number of bytes needed to
 *          store in memory a datum indicated by type.
 *
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage3D if
 *          texture is not the name of an existing texture object.
 *
 *          Check that INVALID_ENUM is generated by TextureSubImage3D if format is
 *          not an accepted format constant.
 *
 *          Check that INVALID_ENUM is generated by TextureSubImage3D if type is
 *          not a type constant.
 *
 *          Check that INVALID_VALUE is generated by TextureSubImage3D if level
 *          is less than 0.
 *
 *          Check that INVALID_VALUE may be generated by TextureSubImage3D if level
 *          is greater than log2 max, where max is the returned value of
 *          MAX_TEXTURE_SIZE.
 *
 *          Check that INVALID_VALUE is generated by TextureSubImage3D if
 *          xoffset<-b, (xoffset+width)>(w-b), yoffset<-b, or
 *          (yoffset+height)>(h-b), or zoffset<-b, or (zoffset+depth)>(d-b), where w
 *          is the TEXTURE_WIDTH, h is the TEXTURE_HEIGHT, d is the TEXTURE_DEPTH
 *          and b is the border width of the texture image being modified. Note
 *          that w, h, and d include twice the border width.
 *
 *          Check that INVALID_VALUE is generated by TextureSubImage3D if width,
 *          height, or depth is less than 0.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage3D if type
 *          is one of UNSIGNED_BYTE_3_3_2, UNSIGNED_BYTE_2_3_3_REV,
 *          UNSIGNED_SHORT_5_6_5, or UNSIGNED_SHORT_5_6_5_REV and format is not RGB.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage3D if type
 *          is one of UNSIGNED_SHORT_4_4_4_4, UNSIGNED_SHORT_4_4_4_4_REV,
 *          UNSIGNED_SHORT_5_5_5_1, UNSIGNED_SHORT_1_5_5_5_REV,
 *          UNSIGNED_INT_8_8_8_8, UNSIGNED_INT_8_8_8_8_REV, UNSIGNED_INT_10_10_10_2,
 *          or UNSIGNED_INT_2_10_10_10_REV and format is neither RGBA nor BGRA.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage3D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and the buffer object's data store is currently mapped.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage3D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and the data would be unpacked from the buffer object such that the
 *          memory reads required would exceed the data store size.
 *
 *          Check that INVALID_OPERATION is generated by TextureSubImage3D if a
 *          non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER target
 *          and pixels is not evenly divisible into the number of bytes needed to
 *          store in memory a datum indicated by type.
 *
 *
 *          Check that INVALID_ENUM is generated by CompressedTextureSubImage1D if
 *          internalformat is not one of the generic compressed internal formats:
 *          COMPRESSED_RED, COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA.
 *          COMPRESSED_SRGB, or COMPRESSED_SRGB_ALPHA.
 *
 *          Check that INVALID_VALUE is generated by CompressedTextureSubImage1D if
 *          imageSize is not consistent with the format, dimensions, and contents of
 *          the specified compressed image data.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage1D
 *          if parameter combinations are not supported by the specific compressed
 *          internal format as specified in the specific texture compression
 *          extension.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage1D
 *          if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
 *          target and the buffer object's data store is currently mapped.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage1D
 *          if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
 *          target and the data would be unpacked from the buffer object such that
 *          the memory reads required would exceed the data store size.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage1D
 *          function if texture is not the name of an existing texture object.
 *
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
 *          if texture is not the name of an existing texture object.
 *
 *          Check that INVALID_ENUM is generated by CompressedTextureSubImage2D if
 *          internalformat is of the generic compressed internal formats:
 *          COMPRESSED_RED, COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA.
 *          COMPRESSED_SRGB, or COMPRESSED_SRGB_ALPHA.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
 *          if format does not match the internal format of the texture image being
 *          modified, since these commands do not provide for image format
 *          conversion.
 *
 *          Check that INVALID_VALUE is generated by CompressedTextureSubImage2D if
 *          imageSize is not consistent with the format, dimensions, and contents of
 *          the specified compressed image data.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
 *          if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
 *          target and the buffer object's data store is currently mapped.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
 *          if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
 *          target and the data would be unpacked from the buffer object such that
 *          the memory reads required would exceed the data store size.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage2D
 *          if the effective target is TEXTURE_RECTANGLE.
 *
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage3D
 *          if texture is not the name of an existing texture object.
 *
 *          Check that INVALID_ENUM is generated by CompressedTextureSubImage3D if
 *          internalformat is one of the generic compressed internal formats:
 *          COMPRESSED_RED, COMPRESSED_RG, COMPRESSED_RGB, COMPRESSED_RGBA.
 *          COMPRESSED_SRGB, or COMPRESSED_SRGB_ALPHA.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage3D
 *          if format does not match the internal format of the texture image being
 *          modified, since these commands do not provide for image format
 *          conversion.
 *
 *          Check that INVALID_VALUE is generated by CompressedTextureSubImage3D if
 *          imageSize is not consistent with the format, dimensions, and contents of
 *          the specified compressed image data.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage3D
 *          if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
 *          target and the buffer object's data store is currently mapped.
 *
 *          Check that INVALID_OPERATION is generated by CompressedTextureSubImage3D
 *          if a non-zero buffer object name is bound to the PIXEL_UNPACK_BUFFER
 *          target and the data would be unpacked from the buffer object such that
 *          the memory reads required would exceed the data store size.
 */
class SubImageErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    SubImageErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    SubImageErrorsTest(const SubImageErrorsTest &other);
    SubImageErrorsTest &operator=(const SubImageErrorsTest &other);

    glw::GLuint m_to_1D_empty;
    glw::GLuint m_to_2D_empty;
    glw::GLuint m_to_3D_empty;
    glw::GLuint m_to_1D;
    glw::GLuint m_to_2D;
    glw::GLuint m_to_3D;
    glw::GLuint m_to_1D_compressed;
    glw::GLuint m_to_2D_compressed;
    glw::GLuint m_to_3D_compressed;
    glw::GLuint m_to_rectangle_compressed;
    glw::GLuint m_to_invalid;
    glw::GLuint m_bo;
    glw::GLuint m_format_invalid;
    glw::GLuint m_type_invalid;
    glw::GLint m_max_texture_size;
    glw::GLubyte *m_reference_compressed_1D;
    glw::GLubyte *m_reference_compressed_2D;
    glw::GLubyte *m_reference_compressed_3D;
    glw::GLubyte *m_reference_compressed_rectangle;
    glw::GLint m_reference_compressed_1D_size;
    glw::GLint m_reference_compressed_2D_size;
    glw::GLint m_reference_compressed_3D_size;
    glw::GLint m_reference_compressed_rectangle_size;
    glw::GLint m_reference_compressed_1D_format;
    glw::GLint m_reference_compressed_2D_format;
    glw::GLint m_reference_compressed_3D_format;
    glw::GLint m_reference_compressed_rectangle_format;
    glw::GLint m_not_matching_compressed_1D_format;
    glw::GLint m_not_matching_compressed_1D_size;
    glw::GLint m_not_matching_compressed_2D_format;
    glw::GLint m_not_matching_compressed_2D_size;
    glw::GLint m_not_matching_compressed_3D_format;
    glw::GLint m_not_matching_compressed_3D_size;

    void Prepare();
    bool Test1D();
    bool Test2D();
    bool Test3D();
    bool Test1DCompressed();
    bool Test2DCompressed();
    bool Test3DCompressed();
    void Clean();

    static const glw::GLushort s_reference[];
    static const glw::GLuint s_reference_width;
    static const glw::GLuint s_reference_height;
    static const glw::GLuint s_reference_depth;
    static const glw::GLuint s_reference_size;
    static const glw::GLenum s_reference_internalformat;
    static const glw::GLenum s_reference_internalformat_compressed;
    static const glw::GLenum s_reference_format;
    static const glw::GLenum s_reference_type;
};
/* SubImageErrorsTest class */

/** @class CopyErrorsTest
 *
 *          Check that INVALID_FRAMEBUFFER_OPERATION is generated by
 *          CopyTextureSubImage1D if the object bound to READ_FRAMEBUFFER_BINDING is
 *          not framebuffer complete.
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage1D if
 *          texture is not the name of an existing texture object, or if the
 *          effective target of texture is not TEXTURE_1D.
 *
 *          Check that INVALID_VALUE is generated by CopyTextureSubImage1D if level
 *          is less than 0.
 *
 *          Check that INVALID_VALUE is generated by CopyTextureSubImage1D if
 *          xoffset<0, or (xoffset+width)>w, where w is the TEXTURE_WIDTH of the
 *          texture image being modified.
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage1D if
 *          the read buffer is NONE, or the value of READ_FRAMEBUFFER_BINDING is
 *          non-zero, and: the read buffer selects an attachment that has no image
 *          attached, or the effective value of SAMPLE_BUFFERS for the read
 *          framebuffer is one.
 *
 *
 *          Check that INVALID_FRAMEBUFFER_OPERATION is generated by
 *          CopyTextureSubImage2D if the object bound to READ_FRAMEBUFFER_BINDING is
 *          not framebuffer complete.
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage2D if
 *          texture is not the name of an existing texture object.
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage2D if
 *          the effective target of texture does not correspond to one of the
 *          texture targets supported by the function.
 *
 *          Check that INVALID_VALUE is generated by CopyTextureSubImage2D if level
 *          is less than 0.
 *
 *          Check that INVALID_VALUE is generated by CopyTextureSubImage2D if
 *          xoffset<0, (xoffset+width)>w, yoffset<0, or (yoffset+height)>0, where w
 *          is the TEXTURE_WIDTH, h is the TEXTURE_HEIGHT and of the texture image
 *          being modified.
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage2D if:
 *          the read buffer is NONE, or the value of READ_FRAMEBUFFER_BINDING is
 *          non-zero, and: the read buffer selects an attachment that has no image
 *          attached, or the effective value of SAMPLE_BUFFERS for the read
 *          framebuffer is one.
 *
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage3D if
 *          the effective target is not TEXTURE_3D, TEXTURE_2D_ARRAY,
 *          TEXTURE_CUBE_MAP_ARRAY or TEXTURE_CUBE_MAP.
 *
 *          Check that INVALID_FRAMEBUFFER_OPERATION is generated by
 *          CopyTextureSubImage3D if the object bound to READ_FRAMEBUFFER_BINDING is
 *          not framebuffer complete.
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage3D if
 *          texture is not the name of an existing texture object.
 *
 *          Check that INVALID_VALUE is generated by CopyTextureSubImage3D if level
 *          is less than 0.
 *
 *          Check that INVALID_VALUE is generated by CopyTextureSubImage3D if
 *          xoffset<0, (xoffset+width)>w, yoffset<0, (yoffset+height)>h, zoffset<0,
 *          or (zoffset+1)>d, where w is the TEXTURE_WIDTH, h is the TEXTURE_HEIGHT,
 *          d is the TEXTURE_DEPTH and of the texture image being modified. Note
 *          that w, h, and d include twice the border width.
 *
 *          Check that INVALID_OPERATION is generated by CopyTextureSubImage3D if:
 *          the read buffer is NONE, or the value of READ_FRAMEBUFFER_BINDING is
 *          non-zero, and: the read buffer selects an attachment that has no image
 *          attached, or the effective value of SAMPLE_BUFFERS for the read
 *          framebuffer is one.
 */
class CopyErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    CopyErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    CopyErrorsTest(const CopyErrorsTest &other);
    CopyErrorsTest &operator=(const CopyErrorsTest &other);

    glw::GLuint m_fbo;
    glw::GLuint m_fbo_ms;
    glw::GLuint m_fbo_incomplete;
    glw::GLuint m_to_src;
    glw::GLuint m_to_src_ms;
    glw::GLuint m_to_1D_dst;
    glw::GLuint m_to_2D_dst;
    glw::GLuint m_to_3D_dst;
    glw::GLuint m_to_invalid;

    void Prepare();
    bool Test1D();
    bool Test2D();
    bool Test3D();
    void Clean();

    static const glw::GLuint s_width;
    static const glw::GLuint s_height;
    static const glw::GLuint s_depth;
    static const glw::GLuint s_internalformat;
};
/* CopyErrorsTest class */

/** @class ParameterSetupErrorsTest
 *
 *      Check that INVALID_ENUM is generated by TextureParameter* if pname is
 *      not one of the accepted defined values.
 *
 *      Check that INVALID_ENUM is generated by TextureParameter* if params
 *      should have a defined constant value (based on the value of pname) and
 *       does not.
 *
 *      Check that INVALID_ENUM is generated if TextureParameter{if} is called
 *      for a non-scalar parameter (pname TEXTURE_BORDER_COLOR or
 *      TEXTURE_SWIZZLE_RGBA).
 *
 *      Check that INVALID_ENUM is generated by TextureParameter* if the
 *      effective target is either TEXTURE_2D_MULTISAMPLE or
 *      TEXTURE_2D_MULTISAMPLE_ARRAY, and pname is any of the sampler states.
 *
 *      Check that INVALID_ENUM is generated by TextureParameter* if the
 *      effective target is TEXTURE_RECTANGLE and either of pnames
 *      TEXTURE_WRAP_S or TEXTURE_WRAP_T is set to either MIRROR_CLAMP_TO_EDGE,
 *      MIRRORED_REPEAT or REPEAT.
 *
 *      Check that INVALID_ENUM is generated by TextureParameter* if the
 *      effective target is TEXTURE_RECTANGLE and pname TEXTURE_MIN_FILTER is
 *      set to a value other than NEAREST or LINEAR (no mipmap filtering is
 *      permitted).
 *
 *      Check that INVALID_OPERATION is generated by TextureParameter* if the
 *      effective target is either TEXTURE_2D_MULTISAMPLE or
 *      TEXTURE_2D_MULTISAMPLE_ARRAY, and pname TEXTURE_BASE_LEVEL is set to a
 *      value other than zero.
 *
 *      Check that INVALID_OPERATION is generated by TextureParameter* if
 *      texture is not the name of an existing texture object.
 *
 *      Check that INVALID_OPERATION is generated by TextureParameter* if the
 *      effective target is TEXTURE_RECTANGLE and pname TEXTURE_BASE_LEVEL is
 *      set to any value other than zero.
 *
 *      Check that INVALID_VALUE is generated by TextureParameter* if pname is
 *      TEXTURE_BASE_LEVEL or TEXTURE_MAX_LEVEL, and param or params is
 *      negative.
 */
class ParameterSetupErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    ParameterSetupErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    ParameterSetupErrorsTest(const ParameterSetupErrorsTest &other);
    ParameterSetupErrorsTest &operator=(const ParameterSetupErrorsTest &other);

    glw::GLuint m_to_2D;
    glw::GLuint m_to_2D_ms;
    glw::GLuint m_to_rectangle;
    glw::GLuint m_to_invalid;
    glw::GLenum m_pname_invalid;
    glw::GLenum m_depth_stencil_mode_invalid;

    void Prepare();
    bool Testf();
    bool Testi();
    bool Testfv();
    bool Testiv();
    bool TestIiv();
    bool TestIuiv();
    void Clean();

    static const glw::GLuint s_width;
    static const glw::GLuint s_height;
    static const glw::GLuint s_depth;
    static const glw::GLuint s_internalformat;
};
/* ParameterSetupErrorsTest class */

/** @class GenerateMipmapErrorsTest
 *
 *      Check that INVALID_OPERATION is generated by GenerateTextureMipmap if
 *      texture is not the name of an existing texture object.
 *
 *      Check that INVALID_OPERATION is generated by GenerateTextureMipmap if
 *      target is TEXTURE_CUBE_MAP or TEXTURE_CUBE_MAP_ARRAY, and the specified
 *      texture object is not cube complete or cube array complete,
 *      respectively.
 */
class GenerateMipmapErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    GenerateMipmapErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    GenerateMipmapErrorsTest(const GenerateMipmapErrorsTest &other);
    GenerateMipmapErrorsTest &operator=(const GenerateMipmapErrorsTest &other);

    static const glw::GLubyte s_reference_data[];
    static const glw::GLuint s_reference_width;
    static const glw::GLuint s_reference_height;
    static const glw::GLenum s_reference_internalformat;
    static const glw::GLenum s_reference_format;
    static const glw::GLenum s_reference_type;
};
/* GenerateMipmapErrorsTest class */

/** @class BindUnitErrorsTest
 *
 *      Check that INVALID_OPERATION error is generated if texture is not zero
 *      or the name of an existing texture object.
 */
class BindUnitErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    BindUnitErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    BindUnitErrorsTest(const BindUnitErrorsTest &other);
    BindUnitErrorsTest &operator=(const BindUnitErrorsTest &other);
};
/* BindUnitErrorsTest class */

/** @class ImageQueryErrorsTest
 *
 *      Check that INVALID_OPERATION is generated by GetTextureImage if texture
 *      is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM is generated by GetTextureImage functions if
 *      resulting texture target is not an accepted value TEXTURE_1D,
 *      TEXTURE_2D, TEXTURE_3D, TEXTURE_1D_ARRAY, TEXTURE_2D_ARRAY,
 *      TEXTURE_CUBE_MAP_ARRAY, TEXTURE_RECTANGLE, and TEXTURE_CUBE_MAP.
 *
 *      Check that INVALID_OPERATION error is generated by GetTextureImage if
 *      the effective target is TEXTURE_CUBE_MAP or TEXTURE_CUBE_MAP_ARRAY, and
 *      the texture object is not cube complete or cube array complete,
 *      respectively.
 *
 *      Check that GL_INVALID_VALUE is generated if level is less than 0 or
 *      larger than the maximum allowable level.
 *
 *      Check that INVALID_VALUE error is generated if level is non-zero and the
 *      effective target is TEXTURE_RECTANGLE.
 *
 *      Check that INVALID_OPERATION error is generated if any of the following
 *      mismatches between format and the internal format of the texture image
 *      exist:
 *       -  format is a color format (one of the formats in table 8.3 whose
 *          target is the color buffer) and the base internal format of the
 *          texture image is not a color format.
 *       -  format is DEPTH_COMPONENT and the base internal format is  not
 *          DEPTH_COMPONENT or DEPTH_STENCIL
 *       -  format is DEPTH_STENCIL and the base internal format is not
 *          DEPTH_STENCIL
 *       -  format is STENCIL_INDEX and the base internal format is not
 *          STENCIL_INDEX or DEPTH_STENCIL
 *       -  format is one of the integer formats in table 8.3 and the internal
 *          format of the texture image is not integer, or format is not one of
 *          the integer formats in table 8.3 and the internal format is integer.
 *
 *      Check that INVALID_OPERATION error is generated if a pixel pack buffer
 *      object is bound and packing the texture image into the buffer's memory
 *      would exceed the size of the buffer.
 *
 *      Check that INVALID_OPERATION error is generated if a pixel pack buffer
 *      object is bound and pixels is not evenly divisible by the number of
 *      basic machine units needed to store in memory the GL data type
 *      corresponding to type (see table 8.2).
 *
 *      Check that INVALID_OPERATION error is generated by GetTextureImage if
 *      the buffer size required to store the requested data is greater than
 *      bufSize.
 *
 *
 *      Check that INVALID_OPERATION is generated by GetCompressedTextureImage
 *      if texture is not the name of an existing texture object.
 *
 *      Check that INVALID_VALUE is generated by GetCompressedTextureImage if
 *      level is less than zero or greater than the maximum number of LODs
 *      permitted by the implementation.
 *
 *      Check that INVALID_OPERATION is generated if GetCompressedTextureImage
 *      is used to retrieve a texture that is in an uncompressed internal
 *      format.
 *
 *      Check that INVALID_OPERATION is generated by GetCompressedTextureImage
 *      if a non-zero buffer object name is bound to the PIXEL_PACK_BUFFER
 *      target, the buffer storage was not initialized with BufferStorage using
 *      MAP_PERSISTENT_BIT flag, and the buffer object's data store is currently
 *      mapped.
 *
 *      Check that INVALID_OPERATION is generated by GetCompressedTextureImage
 *      if a non-zero buffer object name is bound to the PIXEL_PACK_BUFFER
 *      target and the data would be packed to the buffer object such that the
 *      memory writes required would exceed the data store size.
 */
class ImageQueryErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    ImageQueryErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    ImageQueryErrorsTest(const ImageQueryErrorsTest &other);
    ImageQueryErrorsTest &operator=(const ImageQueryErrorsTest &other);

    static const glw::GLuint s_reference_data[];
    static const glw::GLuint s_reference_width;
    static const glw::GLuint s_reference_height;
    static const glw::GLuint s_reference_size;
    static const glw::GLenum s_reference_internalformat;
    static const glw::GLenum s_reference_internalformat_int;
    static const glw::GLenum s_reference_internalformat_compressed;
    static const glw::GLenum s_reference_format;
    static const glw::GLenum s_reference_type;
};
/* ImageQueryErrorsTest class */

/** @class LevelParameterErrorsTest
 *
 *      Check that INVALID_OPERATION is generated by GetTextureLevelParameterfv
 *      and GetTextureLevelParameteriv functions if texture is not the name of
 *      an existing texture object.
 *
 *      Check that INVALID_VALUE is generated by GetTextureLevelParameter* if
 *      level is less than 0.
 *
 *      Check that INVALID_VALUE may be generated if level is greater than
 *      log2 max, where max is the returned value of MAX_TEXTURE_SIZE.
 *
 *      Check that INVALID_OPERATION is generated by GetTextureLevelParameter*
 *      if TEXTURE_COMPRESSED_IMAGE_SIZE is queried on texture images with an
 *      uncompressed internal format or on proxy targets.
 *
 *      Check that INVALID_ENUM error is generated by GetTextureLevelParameter*
 *      if pname is not one of supported constants.
 */
class LevelParameterErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    LevelParameterErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    LevelParameterErrorsTest(const LevelParameterErrorsTest &other);
    LevelParameterErrorsTest &operator=(const LevelParameterErrorsTest &other);
};
/* LevelParameterErrorsTest class */

/** @class
 *      Check that INVALID_ENUM is generated by glGetTextureParameter* if pname
 *      is not an accepted value.
 *
 *      Check that INVALID_OPERATION is generated by glGetTextureParameter* if
 *      texture is not the name of an existing texture object.
 *
 *      Check that INVALID_ENUM error is generated if the effective target is
 *      not one of the supported texture targets (eg. TEXTURE_BUFFER).
 */
class ParameterErrorsTest : public deqp::TestCase, ErrorsUtilities
{
public:
    /* Public member functions. */
    ParameterErrorsTest(deqp::Context &context);

    virtual tcu::TestNode::IterateResult iterate();

private:
    /* Private constructors. */
    ParameterErrorsTest(const ParameterErrorsTest &other);
    ParameterErrorsTest &operator=(const ParameterErrorsTest &other);
};
/* ParameterErrorsTest class */
} // namespace Textures
} // namespace DirectStateAccess
} // namespace gl4cts

#endif // _GL4CDIRECTSTATEACCESSTESTS_HPP