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

#ifndef _GL4CPIPELINESTATISTICSQUERYTESTS_HPP
#define _GL4CPIPELINESTATISTICSQUERYTESTS_HPP
/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2014-2016 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  gl4c PipelineStatisticsQueryTests.hpp
 * \brief Declares test classes that verify conformance of the
 *        GL implementation with GL_ARB_pipeline_statistics_query
 *        extension specification.
 */ /*-------------------------------------------------------------------*/

#include "glcTestCase.hpp"
#include "glwDefs.hpp"
#include "tcuDefs.hpp"
#include <limits.h>
#include <sstream>
#include <string.h>

namespace glcts
{
class PipelineStatisticsQueryUtilities
{
public:
    /* Public type definitions */
    typedef bool (*PFNQUERYDRAWHANDLERPROC)(void *user_arg);

    /* Type of the draw call used for a test iteration */
    enum _draw_call_type
    {
        /* glDrawArrays() */
        DRAW_CALL_TYPE_GLDRAWARRAYS,
        /* glDrawArraysIndirect() */
        DRAW_CALL_TYPE_GLDRAWARRAYSINDIRECT,
        /* glDrawArraysInstanced() */
        DRAW_CALL_TYPE_GLDRAWARRAYSINSTANCED,
        /* glDrawArraysInstancedBaseInstance() */
        DRAW_CALL_TYPE_GLDRAWARRAYSINSTANCEDBASEINSTANCE,
        /* glDrawElements() */
        DRAW_CALL_TYPE_GLDRAWELEMENTS,
        /* glDrawElementsBaseVertex() */
        DRAW_CALL_TYPE_GLDRAWELEMENTSBASEVERTEX,
        /* glDrawElementsIndirect() */
        DRAW_CALL_TYPE_GLDRAWELEMENTSINDIRECT,
        /* glDrawElementsInstanced() */
        DRAW_CALL_TYPE_GLDRAWELEMENTSINSTANCED,
        /* glDrawElementsInstancedBaseInstance() */
        DRAW_CALL_TYPE_GLDRAWELEMENTSINSTANCEDBASEINSTANCE,
        /* glDrawElementsInstancedBaseVertexBaseInstance() */
        DRAW_CALL_TYPE_GLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE,
        /* glDrawRangeElements() */
        DRAW_CALL_TYPE_GLDRAWRANGEELEMENTS,
        /* glDrawRangeElementsBaseVertex() */
        DRAW_CALL_TYPE_GLDRAWRANGEELEMENTSBASEVERTEX,

        /* Always last */
        DRAW_CALL_TYPE_COUNT
    };

    /* Input primitive type defined in geometry shader body used by a test iteration */
    enum _geometry_shader_input
    {
        GEOMETRY_SHADER_INPUT_FIRST,

        GEOMETRY_SHADER_INPUT_POINTS = GEOMETRY_SHADER_INPUT_FIRST,
        GEOMETRY_SHADER_INPUT_LINES,
        GEOMETRY_SHADER_INPUT_LINES_ADJACENCY,
        GEOMETRY_SHADER_INPUT_TRIANGLES,
        GEOMETRY_SHADER_INPUT_TRIANGLES_ADJACENCY,

        /* Always last */
        GEOMETRY_SHADER_INPUT_COUNT
    };

    /* Output primitive type defined in geometry shader body used by a test iteration */
    enum _geometry_shader_output
    {
        GEOMETRY_SHADER_OUTPUT_FIRST,

        GEOMETRY_SHADER_OUTPUT_POINTS = GEOMETRY_SHADER_OUTPUT_FIRST,
        GEOMETRY_SHADER_OUTPUT_LINE_STRIP,
        GEOMETRY_SHADER_OUTPUT_TRIANGLE_STRIP,

        /* Always last */
        GEOMETRY_SHADER_OUTPUT_COUNT
    };

    /* Primitive type used for a draw call */
    enum _primitive_type
    {
        PRIMITIVE_TYPE_FIRST,

        /* GL_POINTS */
        PRIMITIVE_TYPE_POINTS = PRIMITIVE_TYPE_FIRST,
        /* GL_LINE_LOOP */
        PRIMITIVE_TYPE_LINE_LOOP,
        /* GL_LINE_STRIP */
        PRIMITIVE_TYPE_LINE_STRIP,
        /* GL_LINES */
        PRIMITIVE_TYPE_LINES,
        /* GL_LINES_ADJACENCY */
        PRIMITIVE_TYPE_LINES_ADJACENCY,
        /* GL_PATCHES */
        PRIMITIVE_TYPE_PATCHES,
        /* GL_TRIANGLE_FAN */
        PRIMITIVE_TYPE_TRIANGLE_FAN,
        /* GL_TRIANGLE_STRIP */
        PRIMITIVE_TYPE_TRIANGLE_STRIP,
        /* GL_TRIANGLES */
        PRIMITIVE_TYPE_TRIANGLES,
        /* GL_TRIANGLES_ADJACENCY */
        PRIMITIVE_TYPE_TRIANGLES_ADJACENCY,

        /* Always last */
        PRIMITIVE_TYPE_COUNT
    };

    /* Stores result of a single test iteration. */
    struct _test_execution_result
    {
        /* true if 64-bit signed integer counter value was retrieved for the iteration,
         * false otherwise.
         */
        bool int64_written;
        /* true if 64-bit unsigned integer counter value was retrieved for the iteration,
         * false otherwise.
         */
        bool uint64_written;

        /* 32-bit signed integer counter value, as stored in the query buffer object
         * used for the test iteration. This variable will only be modified if query
         * buffer objects are supported.
         */
        glw::GLint result_qo_int;
        /* 64-bit signed integer counter value, as stored in the query buffer object
         * used for the test iteration. This variable will only be modified if query
         * buffer objects are supported, and int64_written is true.
         */
        glw::GLint64 result_qo_int64;
        /* 32-bit unsigned integer counter value, as stored in the query buffer object
         * used for the test iteration. This variable will only be modified if query
         * buffer objects are supported.
         */
        glw::GLuint result_qo_uint;
        /* 64-bit unsigned integer counter value, as stored in the query buffer object
         * used for the test iteration. This variable will only be modified if query
         * buffer objects are supported, and uint64_written is true.
         */
        glw::GLuint64 result_qo_uint64;

        /* 32-bit signed integer counter value, as stored in the query object
         * used for the test iteration.
         */
        glw::GLint result_int;
        /* 64-bit signed integer counter value, as stored in the query object
         * used for the test iteration. Only set if int64_written is true.
         */
        glw::GLint64 result_int64;
        /* 32-bit unsigned integer counter value, as stored in the query object
         * used for the test iteration.
         */
        glw::GLuint result_uint;
        /* 64-bit unsigned integer counter value, as stored in the query object
         * used for the test iteration. Only set if uint64_written is true.
         */
        glw::GLuint64 result_uint64;

        /* Constructor */
        _test_execution_result()
        {
            result_qo_int    = INT_MAX;
            result_qo_int64  = LLONG_MAX;
            result_qo_uint   = UINT_MAX;
            result_qo_uint64 = ULLONG_MAX;

            result_int    = INT_MAX;
            result_int64  = LLONG_MAX;
            result_uint   = UINT_MAX;
            result_uint64 = ULLONG_MAX;

            int64_written  = false;
            uint64_written = false;
        }
    };

    /* Tells how the result values should be verified against
     * the reference value.
     */
    enum _verification_type
    {
        /* The result value should be equal to the reference value */
        VERIFICATION_TYPE_EXACT_MATCH,
        /* The result value should be equal or larger than the reference value */
        VERIFICATION_TYPE_EQUAL_OR_GREATER,

        VERIFICATION_TYPE_UNDEFINED
    };

    /* Code of a compute shader used by a functional test that verifies
     * GL_COMPUTE_SHADER_INVOCATIONS_ARB query works correctly.
     */
    static const char *minimal_cs_code;
    static const char *minimal_cs_code_arb;
    /* Code of a fragment shader used by a number of functional tests */
    static const char *minimal_fs_code;
    /* Code of a tessellation control shader used by a functional test that verifies
     * GL_TESS_CONTROL_SHADER_PATCHES_ARB and GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB
     * queries work correctly.
     */
    static const char *minimal_tc_code;
    /* Code of a tessellation evaluation shader used by a functional test that verifies
     * GL_TESS_CONTROL_SHADER_PATCHES_ARB and GL_TESS_EVALUATION_SHADER_INVOCATIONS_ARB
     * queries work correctly.
     */
    static const char *minimal_te_code;
    /* Code of a vertex shader used by a number of functional tests */
    static const char *minimal_vs_code;

    /* Tells how many query targets are stored in query_targets */
    static const unsigned int n_query_targets;
    /* Stores all query targets that should be used by the tests */
    static const glw::GLenum query_targets[];

    /* Tells the offset, relative to the beginning of the buffer object storage,
     * from which the query's int32 result value starts. */
    static const unsigned int qo_bo_int_offset;
    /* Tells the offset, relative to the beginning of the buffer object storage,
     * from which the query's int64 result value starts. */
    static const unsigned int qo_bo_int64_offset;
    /* Tells the offset, relative to the beginning of the buffer object storage,
     * from which the query's uint32 result value starts. */
    static const unsigned int qo_bo_uint_offset;
    /* Tells the offset, relative to the beginning of the buffer object storage,
     * from which the query's uint64 result value starts. */
    static const unsigned int qo_bo_uint64_offset;
    static const unsigned int qo_bo_size;

    /* Public methods */
    static std::string buildGeometryShaderBody(_geometry_shader_input gs_input, _geometry_shader_output gs_output,
                                               unsigned int n_primitives_to_emit_in_stream0, unsigned int n_streams);

    static bool executeQuery(glw::GLenum query_type, glw::GLuint qo_id, glw::GLuint qo_bo_id,
                             PFNQUERYDRAWHANDLERPROC pfn_draw, void *draw_user_arg,
                             const glu::RenderContext &render_context, tcu::TestContext &test_context,
                             const glu::ContextInfo &context_info, _test_execution_result *out_result, bool &skipped);

    static glw::GLenum getEnumForPrimitiveType(_primitive_type primitive_type);
    static std::string getGLSLStringForGSInput(_geometry_shader_input gs_input);
    static std::string getGLSLStringForGSOutput(_geometry_shader_output gs_output);
    static unsigned int getNumberOfVerticesForGSInput(_geometry_shader_input gs_input);
    static unsigned int getNumberOfVerticesForGSOutput(_geometry_shader_output gs_output);
    static unsigned int getNumberOfVerticesForPrimitiveType(_primitive_type primitive_type);
    static _primitive_type getPrimitiveTypeFromGSInput(_geometry_shader_input gs_input);
    static std::string getStringForDrawCallType(_draw_call_type draw_call_type);
    static std::string getStringForEnum(glw::GLenum value);
    static std::string getStringForPrimitiveType(_primitive_type primitive_type);

    static bool isDrawCallSupported(_draw_call_type draw_call, const glw::Functions &gl);

    static bool isInstancedDrawCall(_draw_call_type draw_call);

    static bool isQuerySupported(glw::GLenum value, const glu::ContextInfo &context_info,
                                 const glu::RenderContext &render_context);

    static bool verifyResultValues(const _test_execution_result &run_result, unsigned int n_expected_values,
                                   const glw::GLuint64 *expected_values, bool should_check_qo_bo_values,
                                   const glw::GLenum query_type, const _draw_call_type *draw_call_type_ptr,
                                   const _primitive_type *primitive_type_ptr, bool is_primitive_restart_enabled,
                                   tcu::TestContext &test_context, _verification_type verification_type);

    /** Constructs a string that describes details of a test iteration that has been
     *  detected to have failed.
     *
     *  @param value                        Query counter value as retrieved by the test iteration.
     *  @param value_type                   Null-terminated string holding the name of the type
     *                                      of the result value.
     *  @param n_expected_values            Number of possible expected values.
     *  @param expected_values              Array of possible expected values.
     *  @param query_type                   Type of the query used by the test iteration.
     *  @param draw_call_type_name          Type of the draw call used by the test iteration.
     *  @param primitive_type_name          Primitive type used for the test iteration's draw call.
     *  @param is_primitive_restart_enabled true if the test iteration was run with "primitive restart"
     *                                      functionality enabled, false otherwise.
     *
     *  @return                             String that includes a human-readable description of the
     *                                      test iteration's properties.
     *
     */
    template <typename VALUE_TYPE>
    static std::string getVerifyResultValuesErrorString(VALUE_TYPE value, const char *value_type,
                                                        unsigned int n_expected_values,
                                                        const glw::GLuint64 *expected_values, glw::GLenum query_type,
                                                        std::string draw_call_type_name,
                                                        std::string primitive_type_name,
                                                        bool is_primitive_restart_enabled)
    {
        std::stringstream log_sstream;

        DE_ASSERT(expected_values != DE_NULL);

        log_sstream << "Invalid default " << value_type
                    << " query result value: found "
                       "["
                    << value
                    << "], expected:"
                       "["
                    << expected_values[0] << "]";

        for (unsigned int i = 1; i < n_expected_values; ++i)
        {
            log_sstream << " or [" << expected_values[i] << "]";
        }

        log_sstream << ", query type:"
                       "["
                    << getStringForEnum(query_type)
                    << "], "
                       "GL_PRIMITIVE_RESTART mode:"
                       "["
                    << ((is_primitive_restart_enabled) ? "enabled" : "disabled")
                    << "]"
                       ", draw call type:"
                       "["
                    << draw_call_type_name.c_str()
                    << "]"
                       ", primitive type:"
                       "["
                    << primitive_type_name.c_str() << "].";

        return log_sstream.str();
    }
};

/** Check that calling BeginQuery with a pipeline statistics query target
 *  generates an INVALID_OPERATION error if the specified query was
 *  previously used with a different pipeline statistics query target.
 **/
class PipelineStatisticsQueryTestAPICoverage1 : public deqp::TestCase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestAPICoverage1(deqp::Context &context);

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

private:
    /* Private fields */
    glw::GLuint m_qo_id;
};

/** Performs the following tests:
 *
 *  * If GL 3.2 and ARB_geometry_shader4 are not supported then check that
 *    calling BeginQuery with target GEOMETRY_SHADER_INVOCATIONS or
 *    GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB generates an INVALID_ENUM error.
 *
 *  * If GL 4.0 and ARB_tessellation_shader are not supported then check that
 *    calling BeginQuery with target TESS_CONTROL_SHADER_INVOCATIONS_ARB or
 *    TESS_EVALUATION_SHADER_INVOCATIONS_ARB generates an INVALID_ENUM error.
 *
 *  * If GL 4.3 and ARB_compute_shader are not supported then check that
 *    calling BeginQuery with target COMPUTE_SHADER_INVOCATIONS_ARB generates
 *    an INVALID_ENUM error.
 *
 **/
class PipelineStatisticsQueryTestAPICoverage2 : public deqp::TestCase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestAPICoverage2(deqp::Context &context);

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

private:
    /* Private fields */
    glw::GLuint m_qo_id;
};

/** Base class used by all functional test implementations. Provides various
 *  methods that are shared between functional tests.
 *
 *  Derivative classes must implement executeTest() method.
 */
class PipelineStatisticsQueryTestFunctionalBase : public deqp::TestCase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctionalBase(deqp::Context &context, const char *name, const char *description);

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

protected:
    /* Protected methods */
    void buildProgram(const char *cs_body, const char *fs_body, const char *gs_body, const char *tc_body,
                      const char *te_body, const char *vs_body);

    virtual void deinitObjects();

    virtual bool executeTest(glw::GLenum current_query_target) = 0;
    void initFBO();
    virtual void initObjects();
    void initQOBO();
    void initVAO(unsigned int n_components_per_vertex);

    void initVBO(const float *raw_vertex_data, unsigned int raw_vertex_data_size, const unsigned int *raw_index_data,
                 unsigned int raw_index_data_size, unsigned int indirect_draw_bo_count_argument,
                 unsigned int indirect_draw_bo_primcount_argument, unsigned int indirect_draw_bo_baseinstance_argument,
                 unsigned int indirect_draw_bo_first_argument,       /* glDrawArrays() only */
                 unsigned int indirect_draw_bo_basevertex_argument); /* glDrawElements() only */

    virtual bool shouldExecuteForQueryTarget(glw::GLenum query_target);

    /* Protected static methods */
    static bool queryCallbackDrawCallHandler(void *pThis);

    /* Protected fields */
    glw::GLuint m_bo_qo_id;
    glw::GLuint m_fbo_id;
    glw::GLuint m_po_id;
    glw::GLuint m_qo_id;
    glw::GLuint m_to_id;
    glw::GLuint m_vao_id;
    glw::GLuint m_vbo_id;

    const unsigned int m_to_height;
    const unsigned int m_to_width;

    unsigned int m_vbo_indirect_arrays_argument_offset;
    unsigned int m_vbo_indirect_elements_argument_offset;
    unsigned int m_vbo_index_data_offset;
    unsigned int m_vbo_n_indices;
    unsigned int m_vbo_vertex_data_offset;

    PipelineStatisticsQueryUtilities::_draw_call_type m_current_draw_call_type;
    PipelineStatisticsQueryUtilities::_primitive_type m_current_primitive_type;
    unsigned int m_indirect_draw_call_baseinstance_argument;
    unsigned int m_indirect_draw_call_basevertex_argument;
    unsigned int m_indirect_draw_call_count_argument;
    unsigned int m_indirect_draw_call_first_argument;
    unsigned int m_indirect_draw_call_firstindex_argument;
    unsigned int m_indirect_draw_call_primcount_argument;
};

/** Performs the following functional test:
 *
 * Check that all pipeline statistics query types return a result of zero
 * if no rendering commands are issued between BeginQuery and EndQuery.
 *
 **/
class PipelineStatisticsQueryTestFunctional1 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional1(deqp::Context &context);

protected:
    /* Protected methods */
    bool executeTest(glw::GLenum current_query_target);
};

/** Performs the following functional test:
 *
 * Check that all pipeline statistics query types return a result of zero
 * if Clear, ClearBuffer*, BlitFramebuffer, or any of the non-rendering
 * commands involving blits or copies (e.g. TexSubImage, CopyImageSubData,
 * ClearTexSubImage, BufferSubData, ClearBufferSubData) are issued between
 * BeginQuery and EndQuery.
 *
 **/
class PipelineStatisticsQueryTestFunctional2 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional2(deqp::Context &context);

protected:
    /* Protected methods */
    void deinitObjects();
    bool executeTest(glw::GLenum current_query_target);
    void initObjects();

private:
    static bool executeBlitFramebufferTest(void *pThis);
    static bool executeBufferSubDataTest(void *pThis);
    static bool executeClearBufferfvColorBufferTest(void *pThis);
    static bool executeClearBufferfvDepthBufferTest(void *pThis);
    static bool executeClearBufferivStencilBufferTest(void *pThis);
    static bool executeClearBufferSubDataTest(void *pThis);
    static bool executeClearColorBufferTest(void *pThis);
    static bool executeClearDepthBufferTest(void *pThis);
    static bool executeClearStencilBufferTest(void *pThis);
    static bool executeClearTexSubImageTest(void *pThis);
    static bool executeCopyImageSubDataTest(void *pThis);
    static bool executeTexSubImageTest(void *pThis);

    /* Private fields */
    glw::GLuint m_bo_id;
    glw::GLuint m_fbo_draw_id;
    glw::GLuint m_fbo_read_id;
    glw::GLuint m_to_draw_fbo_id;
    glw::GLuint m_to_read_fbo_id;

    const glw::GLuint m_to_height;
    const glw::GLuint m_to_width;

    static const glw::GLuint bo_size;
};

/** Performs the following functional tests:
 *
 * Using the basic outline check that VERTICES_SUBMITTED_ARB queries return
 * the number of vertices submitted using draw commands. Vertices
 * corresponding to partial/incomplete primitives may or may not be counted
 * (e.g. when submitting a single instance with 8 vertices with primitive
 * mode TRIANGLES, the result of the query could be either 6 or 8).
 *
 * Using the basic outline check that VERTICES_SUBMITTED_ARB queries don't
 * count primitive topology restarts when PRIMITIVE_RESTART is enabled and
 * DrawElements* is used to submit an element array which contains one or
 * more primitive restart index values.
 *
 * Using the basic outline check that PRIMITIVES_SUBMITTED_ARB queries
 * return the exact number of primitives submitted using draw commands.
 * Partial/incomplete primitives may or may not be counted (e.g. when
 * submitting a single instance with 8 vertices with primitive mode
 * TRIANGLES, the result of the query could be either 2 or 3). Test the
 * behavior with all supported primitive modes.
 *
 * Using the basic outline check that PRIMITIVES_SUBMITTED_ARB queries
 * don't count primitive topology restarts when PRIMITIVE_RESTART is
 * enabled and DrawElements* is used to submit an element array which
 * contains one or more primitive restart index values. Also, partial/
 * incomplete primitives resulting from the use of primitive restart index
 * values may or may not be counted.
 *
 * Using the basic outline check that CLIPPING_INPUT_PRIMITIVES_ARB queries
 * return the exact number of primitives reaching the primitive clipping
 * stage. If RASTERIZER_DISCARD is disabled, and the tessellation and
 * geometry shader stage is not used, this should match the number of
 * primitives submitted.
 *
 * Using the basic outline check that CLIPPING_OUTPUT_PRIMITIVES_ARB
 * queries return a value that is always greater than or equal to the
 * number of primitives submitted if RASTERIZER_DISCARD is disabled, there
 * is no tessellation and geometry shader stage used, and all primitives
 * lie entirely in the cull volume.
 *
 **/
class PipelineStatisticsQueryTestFunctional3 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional3(deqp::Context &context);

protected:
    /* Protected methods */
    void deinitObjects();
    bool executeTest(glw::GLenum current_query_target);
    void initObjects();
    bool shouldExecuteForQueryTarget(glw::GLenum query_target);

private:
    /* Private methods */
    void getExpectedPrimitivesSubmittedQueryResult(
        PipelineStatisticsQueryUtilities::_primitive_type current_primitive_type, unsigned int *out_results_written,
        glw::GLuint64 out_results[4]);

    void getExpectedVerticesSubmittedQueryResult(
        PipelineStatisticsQueryUtilities::_primitive_type current_primitive_type, unsigned int *out_results_written,
        glw::GLuint64 out_results[4]);

    /* Private fields */
    bool m_is_primitive_restart_enabled;
};

/** Performs the following functional test:
 *
 * Using the basic outline with a program having a vertex shader check that
 * VERTEX_SHADER_INVOCATIONS_ARB queries return a result greater than zero
 * if at least one vertex is submitted to the GL.
 *
 **/
class PipelineStatisticsQueryTestFunctional4 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional4(deqp::Context &context);

protected:
    /* Protected methods */
    void deinitObjects();
    bool executeTest(glw::GLenum current_query_target);
    void initObjects();
    bool shouldExecuteForQueryTarget(glw::GLenum query_target);
};

/** Performs the following functional test:
 *
 * If GL 4.0 is supported, using the basic outline with a program having a
 * tessellation control and tessellation evaluation shader check that
 * TESS_CONTROL_SHADER_INVOCATIONS_ARB and TESS_EVALUATION_SHADER_-
 * INVOCATIONS_ARB queries return a result greater than zero if at least
 * one patch is needed to be processed by the GL (e.g. PATCH_VERTICES is 3,
 * and at least 3 vertices are submitted to the GL).
 *
 **/
class PipelineStatisticsQueryTestFunctional5 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional5(deqp::Context &context);

protected:
    /* Protected methods */
    void deinitObjects();
    bool executeTest(glw::GLenum current_query_target);
    void initObjects();
    bool shouldExecuteForQueryTarget(glw::GLenum query_target);
};

/** Performs the following functional test:
 *
 * If GL 3.2 is supported, using the basic outline with a program having a
 * geometry shader check that GEOMETRY_SHADER_INVOCATIONS queries return
 * a result greater than zero if at least one complete primitive is
 * submitted to the GL.
 *
 * If GL 3.2 is supported, using the basic outline with a program having a
 * geometry shader check that GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB
 * queries return the exact number of primitives emitted by the geometry
 * shader. Also, if GL 4.0 is supported, use a geometry shader that emits
 * primitives to multiple vertex streams. In this case the result of
 * GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB has to match the sum of the
 * number of primitives emitted to each particular vertex stream.
 *
 **/
class PipelineStatisticsQueryTestFunctional6 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional6(deqp::Context &context);

protected:
    /* Protected methods */
    void deinitObjects();
    bool executeTest(glw::GLenum current_query_target);
    void initObjects();
    bool shouldExecuteForQueryTarget(glw::GLenum query_target);

private:
    /* Private fields */
    const unsigned int m_n_primitives_emitted_by_gs;
    const unsigned int m_n_streams_emitted_by_gs;
};

/** Performs the following functional test:
 *
 * Using the basic outline with a program having a fragment shader check
 * that FRAGMENT_SHADER_INVOCATIONS_ARB queries return a result greater
 * than zero if at least one fragment gets rasterized.
 *
 **/
class PipelineStatisticsQueryTestFunctional7 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional7(deqp::Context &context);

protected:
    /* Protected methods */
    void deinitObjects();
    bool executeTest(glw::GLenum current_query_target);
    void initObjects();
    bool shouldExecuteForQueryTarget(glw::GLenum query_target);
};

/** Performs the following functional test:
 *
 * Using the basic outline with a program having a compute shader check
 * that COMPUTE_SHADER_INVOCATIONS_ARB queries return a result greater
 * than zero if at least a single work group is submitted using one of the
 * Dispatch* commands.
 *
 **/
class PipelineStatisticsQueryTestFunctional8 : public PipelineStatisticsQueryTestFunctionalBase
{
public:
    /* Public methods */
    PipelineStatisticsQueryTestFunctional8(deqp::Context &context);

protected:
    /* Protected methods */
    void deinitObjects();
    bool executeTest(glw::GLenum current_query_target);
    void initObjects();
    bool shouldExecuteForQueryTarget(glw::GLenum query_target);

private:
    /* Private methods */
    static bool queryCallbackDispatchCallHandler(void *pInstance);

    /* Private fields */
    glw::GLuint m_bo_dispatch_compute_indirect_args_offset;
    glw::GLuint m_bo_id;
    unsigned int m_current_iteration;
};

/** Test group which encapsulates all conformance tests for
 *  GL_ARB_pipeline_statistics_query extension.
 */
class PipelineStatisticsQueryTests : public deqp::TestCaseGroup
{
public:
    /* Public methods */
    PipelineStatisticsQueryTests(deqp::Context &context);

    void init(void);

private:
    PipelineStatisticsQueryTests(const PipelineStatisticsQueryTests &other);
    PipelineStatisticsQueryTests &operator=(const PipelineStatisticsQueryTests &other);
};

} // namespace glcts

#endif // _GL4CPIPELINESTATISTICSQUERYTESTS_HPP