/*-------------------------------------------------------------------------
 * 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 esextcGeometryShaderLimits.cpp
 * \brief Geometry Shader Limits (Test Group 16)
 */ /*-------------------------------------------------------------------*/

#include "esextcGeometryShaderLimits.hpp"

#include "gluContextInfo.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"

#include <cstring>
#include <sstream>
#include <string>

namespace glcts
{
/* Vertex Shader for GeometryShaderMaxUniformComponentsTest */
const glw::GLchar *const GeometryShaderMaxUniformComponentsTest::m_vertex_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(gl_VertexID, 0, 0, 1);\n"
    "}\n";

/* Geometry Shader parts for GeometryShaderMaxUniformComponentsTest */
const glw::GLchar *const GeometryShaderMaxUniformComponentsTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "layout(points)                 in;\n"
    "layout(points, max_vertices=1) out;\n"
    "\n"
    "// definition of NUMBER_OF_UNIFORMS goes here\n";

const glw::GLchar *const GeometryShaderMaxUniformComponentsTest::m_geometry_shader_code_number_of_uniforms =
    "#define NUMBER_OF_UNIFORMS ";

const glw::GLchar *const GeometryShaderMaxUniformComponentsTest::m_geometry_shader_code_body =
    "u\n"
    "\n"
    "uniform ivec4 uni_array[NUMBER_OF_UNIFORMS];\n"
    "\n"
    "flat out uint gs_out_sum;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gs_out_sum = 0u;\n"
    "\n"
    "    for (uint i = 0u; i < NUMBER_OF_UNIFORMS; ++i)\n"
    "    {\n"
    "        gs_out_sum += uint(uni_array[i].x);\n"
    "        gs_out_sum += uint(uni_array[i].y);\n"
    "        gs_out_sum += uint(uni_array[i].z);\n"
    "        gs_out_sum += uint(uni_array[i].w);\n"
    "    }\n"
    "    EmitVertex();\n"
    "    \n"
    "    EndPrimitive();\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxUniformComponentsTest */
const glw::GLchar *const GeometryShaderMaxUniformComponentsTest::m_fragment_shader_code =
    "${VERSION}\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "precision mediump float;\n"
    "out vec4 fs_out_color;\n"
    "void main()\n"
    "{\n"
    "    fs_out_color = vec4(1, 1, 1, 1);\n"
    "}\n";

/** ***************************************************************************************************** **/
/* Vertex Shader for GeometryShaderMaxUniformBlocksTest */
const glw::GLchar *const GeometryShaderMaxUniformBlocksTest::m_vertex_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(gl_VertexID, 0, 0, 1);\n"
    "}\n";

/* Geometry Shader Parts for GeometryShaderMaxUniformBlocksTest */
const glw::GLchar *const GeometryShaderMaxUniformBlocksTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "layout(points)                 in;\n"
    "layout(points, max_vertices=1) out;\n"
    "\n"
    "// definition of NUMBER_OF_UNIFORMS goes here\n";

const glw::GLchar *const GeometryShaderMaxUniformBlocksTest::m_geometry_shader_code_number_of_uniforms =
    "#define NUMBER_OF_UNIFORM_BLOCKS ";

const glw::GLchar *const GeometryShaderMaxUniformBlocksTest::m_geometry_shader_code_body_str =
    "u\n"
    "\n"
    "layout(binding = 0) uniform UniformBlock\n"
    "{\n"
    "    int entry;\n"
    "} uni_block_array[NUMBER_OF_UNIFORM_BLOCKS];\n"
    "\n"
    "flat out int gs_out_sum;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gs_out_sum = 0;\n"
    "\n";

const glw::GLchar *const GeometryShaderMaxUniformBlocksTest::m_geometry_shader_code_body_end = "\n"
                                                                                               "    EmitVertex();\n"
                                                                                               "\n"
                                                                                               "    EndPrimitive();\n"
                                                                                               "}\n";

/* Fragment Shader for GeometryShaderMaxUniformBlocksTest */
const glw::GLchar *const GeometryShaderMaxUniformBlocksTest::m_fragment_shader_code =
    "${VERSION}\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "precision mediump float;\n"
    "out vec4 fs_out_color;\n"
    "void main()\n"
    "{\n"
    "    fs_out_color = vec4(1, 1, 1, 1);\n"
    "}\n";

/** ****************************************************************************************** **/
/* Vertex Shader for GeometryShaderMaxInputComponentsTest */
const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_vertex_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "// definition of NUMBER_OF_GEOMETRY_INPUT_VECTORS\n";

const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_vertex_shader_code_number_of_uniforms =
    "#define NUMBER_OF_GEOMETRY_INPUT_VECTORS ";

const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_vertex_shader_code_body =
    "u\n"
    "\n"
    "out Vertex\n"
    "{"
    "   flat out ivec4 vs_gs_out[NUMBER_OF_GEOMETRY_INPUT_VECTORS];\n"
    "};\n"
    "\n"
    "void main()\n"
    "{\n"
    "   int index = 1;\n"
    "\n"
    "   for (uint i = 0u; i < NUMBER_OF_GEOMETRY_INPUT_VECTORS; ++i)\n"
    "   {\n"
    "       vs_gs_out[i] = ivec4(index, index + 1, index + 2, index + 3);\n"
    "       index       += 4;\n"
    "   }\n"
    "}\n";

/* Geometry Shader Parts for GeometryShaderMaxInputComponentsTest */
const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "layout(points)                 in;\n"
    "layout(points, max_vertices=1) out;\n"
    "\n"
    "// definition of NUMBER_OF_GEOMETRY_INPUT_VECTORS goes here\n";

const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_geometry_shader_code_number_of_uniforms =
    "#define NUMBER_OF_GEOMETRY_INPUT_VECTORS ";

const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_geometry_shader_code_body =
    "u\n"
    "\n"
    "in Vertex\n"
    "{\n"
    "    flat in ivec4 vs_gs_out[NUMBER_OF_GEOMETRY_INPUT_VECTORS];\n"
    "} vertex[1];\n"
    "\n"
    "flat out int gs_out_sum;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gs_out_sum = 0;\n"
    "\n"
    "    for (uint i = 0u; i < NUMBER_OF_GEOMETRY_INPUT_VECTORS; ++i)\n"
    "    {\n"
    "        gs_out_sum += vertex[0].vs_gs_out[i].x;\n"
    "        gs_out_sum += vertex[0].vs_gs_out[i].y;\n"
    "        gs_out_sum += vertex[0].vs_gs_out[i].z;\n"
    "        gs_out_sum += vertex[0].vs_gs_out[i].w;\n"
    "    }\n"
    "    EmitVertex();\n"
    "    \n"
    "    EndPrimitive();\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxInputComponentsTest */
const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_fragment_shader_code =
    "${VERSION}\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "precision mediump float;\n"
    "out vec4 fs_out_color;\n"
    "void main()\n"
    "{\n"
    "    fs_out_color = vec4(1, 1, 1, 1);\n"
    "}\n";

/** **************************************************************************************************/
/* Common shader parts for GeometryShaderMaxOutputComponentsTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_common_shader_code_gs_fs_out = "gs_fs_out_";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_common_shader_code_number_of_points =
    "#define NUMBER_OF_POINTS ";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_common_shader_code_gs_fs_out_definitions =
    "// definitions of gs_fs_out_ varyings go here\n";

/* Vertex Shader for GeometryShaderMaxOutputComponentsTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_vertex_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(gl_VertexID, 0, 0, 1);\n"
    "}\n";

/* Geometry Shader Parts for GeometryShaderMaxOutputComponentsTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "${GEOMETRY_POINT_SIZE_ENABLE}\n"
    "\n"
    "// definition of NUMBER_OF_POINTS goes here\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_geometry_shader_code_layout =
    "u\n"
    "\n"
    "layout(points)                                in;\n"
    "layout(points, max_vertices=NUMBER_OF_POINTS) out;\n"
    "\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_geometry_shader_code_flat_out_ivec4 =
    "flat out ivec4";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_geometry_shader_code_assignment =
    " = ivec4(index++, index++, index++, index++);\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_geometry_shader_code_body_begin =
    "\n"
    "void main()\n"
    "{\n"
    "    int index = 1;\n"
    "\n"
    "    for (uint point = 0u; point < NUMBER_OF_POINTS; ++point)\n"
    "    {\n"
    "        // gs_fs_out assignments go here\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_geometry_shader_code_body_end =
    "\n"
    "        gl_PointSize = 2.0;\n"
    "        gl_Position = vec4(-1.0 + ((2.0 / float(NUMBER_OF_POINTS)) * float(point)) + (1.0 / "
    "float(NUMBER_OF_POINTS)), 0.0, 0.0, 1.0);\n"
    "\n"
    "        EmitVertex();\n"
    "        EndPrimitive();\n"
    "    }\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxOutputComponentsTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_fragment_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "precision highp int;\n"
    "\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_fragment_shader_code_flat_in_ivec4 = "flat in ivec4";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_fragment_shader_code_sum = "sum += ";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_fragment_shader_code_body_begin =
    "\n"
    "layout(location = 0) out int fs_out;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    int sum = 0;\n"
    "\n"
    "    // sum calculation go here\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsTest::m_fragment_shader_code_body_end = "\n"
                                                                                                  "    fs_out = sum;\n"
                                                                                                  "}\n";

/** ******************************************************************************************* **/
/* Vertex Shader for GeometryShaderMaxOutputVerticesTest */
const glw::GLchar *const GeometryShaderMaxOutputVerticesTest::m_vertex_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(gl_VertexID, 0, 0, 1);\n"
    "}\n";

/* Geometry Shader for GeometryShaderMaxOutputVerticesTest */
const glw::GLchar *const GeometryShaderMaxOutputVerticesTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "// definition of NUMBER_OF_POINTS goes here\n"
    "#define NUMBER_OF_POINTS ";

const glw::GLchar *const GeometryShaderMaxOutputVerticesTest::m_geometry_shader_code_body =
    "u\n"
    "\n"
    "layout(points)                                in;\n"
    "layout(points, max_vertices=NUMBER_OF_POINTS) out;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    int index = 0;\n"
    "\n"
    "    for (uint point = 0u; point < NUMBER_OF_POINTS; ++point)\n"
    "    {\n"
    "        EmitVertex();\n"
    "        EndPrimitive();\n"
    "    }\n"
    "\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxOutputVerticesTest */
const glw::GLchar *const GeometryShaderMaxOutputVerticesTest::m_fragment_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "layout(location = 0) out vec4 fs_out;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    fs_out = vec4(1, 1, 1, 1);\n"
    "}\n";

/** ***************************************************************************************************************** **/
/* Common shader parts for GeometryShaderMaxOutputComponentsSinglePointTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_common_shader_code_gs_fs_out =
    "gs_fs_out_";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_common_shader_code_gs_fs_out_definitions =
    "// definitions of gs_fs_out_ varyings go here\n";

/* Vertex Shader for GeometryShaderMaxOutputComponentsSinglePointTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_vertex_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(gl_VertexID, 0, 0, 1);\n"
    "}\n";

/* Geometry Shader Parts for GeometryShaderMaxOutputComponentsSinglePointTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "${GEOMETRY_POINT_SIZE_ENABLE}\n"
    "\n"
    "layout(points)                 in;\n"
    "layout(points, max_vertices=1) out;\n"
    "\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_geometry_shader_code_flat_out_ivec4 =
    "flat out ivec4";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_geometry_shader_code_assignment =
    " = ivec4(index++, index++, index++, index++);\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_geometry_shader_code_body_begin =
    "\n"
    "void main()\n"
    "{\n"
    "    int index = 1;\n"
    "\n"
    "    // gs_fs_out assignments go here\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_geometry_shader_code_body_end =
    "\n"
    "    gl_PointSize = 2.0;\n"
    "    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
    "\n"
    "    EmitVertex();\n"
    "    EndPrimitive();\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxOutputComponentsSinglePointTest */
const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_fragment_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_fragment_shader_code_flat_in_ivec4 =
    "flat in ivec4";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_fragment_shader_code_sum = "sum += ";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_fragment_shader_code_body_begin =
    "\n"
    "layout(location = 0) out int fs_out;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    int sum = 0;\n"
    "\n"
    "    // sum calculation go here\n";

const glw::GLchar *const GeometryShaderMaxOutputComponentsSinglePointTest::m_fragment_shader_code_body_end =
    "\n"
    "    fs_out = sum;\n"
    "}\n";

/** ******************************************************************************************************************** **/
/* Vertex Shader for GeometryShaderMaxTextureUnitsTest */
const glw::GLchar *const GeometryShaderMaxTextureUnitsTest::m_vertex_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "#define NUMBER_OF_POINTS ";

const glw::GLchar *const GeometryShaderMaxTextureUnitsTest::m_vertex_shader_code_body =
    "u\n"
    "\n"
    "flat out int vs_gs_vertex_id;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gl_Position     = vec4(-1.0 + ((2.0 / float(NUMBER_OF_POINTS)) * float(gl_VertexID)) + (1.0 / "
    "float(NUMBER_OF_POINTS)), 0, 0, 1.0);\n"
    "    vs_gs_vertex_id = gl_VertexID;\n"
    "}\n";

/* Geometry Shader for GeometryShaderMaxTextureUnitsTest */
const glw::GLchar *const GeometryShaderMaxTextureUnitsTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "${GEOMETRY_POINT_SIZE_ENABLE}\n"
    "${GPU_SHADER5_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "layout(points)                           in;\n"
    "layout(triangle_strip, max_vertices = 4) out;\n"
    "\n"
    "#define NUMBER_OF_POINTS ";

const glw::GLchar *const GeometryShaderMaxTextureUnitsTest::m_geometry_shader_code_body =
    "u\n"
    "\n"
    "// NUMBER_OF_POINTS == NUMBER_OF_SAMPLERS\n"
    "     uniform lowp isampler2D gs_texture[NUMBER_OF_POINTS];\n"
    "flat in      int        vs_gs_vertex_id[1];\n"
    "flat out     int        gs_fs_color;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    float half_of_edge = (1.0 / float(NUMBER_OF_POINTS));\n"
    "    int   color        = 0;\n"
    "\n"
    "    for (uint i = 0u; i <= uint(vs_gs_vertex_id[0]); ++i)\n"
    "    {\n"
    "        color += texture(gs_texture[i], vec2(0.0, 0.0)).r;\n"
    "    }\n"
    "\n"
    "    gl_Position = gl_in[0].gl_Position + vec4(-half_of_edge,  1.0, 0, 0);\n"
    "    gs_fs_color = color;\n"
    "    EmitVertex();\n"
    "\n"
    "    gl_Position = gl_in[0].gl_Position + vec4( half_of_edge,  1.0, 0, 0);\n"
    "    gs_fs_color = color;\n"
    "    EmitVertex();\n"
    "\n"
    "    gl_Position = gl_in[0].gl_Position + vec4(-half_of_edge, -1.0, 0, 0);\n"
    "    gs_fs_color = color;\n"
    "    EmitVertex();\n"
    "\n"
    "    gl_Position = gl_in[0].gl_Position + vec4( half_of_edge, -1.0, 0, 0);\n"
    "    gs_fs_color = color;\n"
    "    EmitVertex();\n"
    "    EndPrimitive();\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxTextureUnitsTest */
const glw::GLchar *const GeometryShaderMaxTextureUnitsTest::m_fragment_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "flat                 in  int gs_fs_color;\n"
    "layout(location = 0) out int fs_out_color;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    fs_out_color = gs_fs_color;\n"
    "}\n";

/** *******************************************************************************************************/
/* Vertex Shader for GeometryShaderMaxInvocationsTest */
const glw::GLchar *const GeometryShaderMaxInvocationsTest::m_vertex_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    gl_Position = vec4(gl_VertexID, 0, 0, 1);\n"
    "}\n";

/* Geometry Shader for GeometryShaderMaxInvocationsTest */
const glw::GLchar *const GeometryShaderMaxInvocationsTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "#define GEOMETRY_SHADER_INVOCATIONS ";

const glw::GLchar *const GeometryShaderMaxInvocationsTest::m_geometry_shader_code_layout =
    "u\n"
    "\n"
    "layout(points) in;\n"
    "layout(triangle_strip, max_vertices = 3) out;\n";

const glw::GLchar *const GeometryShaderMaxInvocationsTest::m_geometry_shader_code_layout_invocations =
    "layout(invocations = GEOMETRY_SHADER_INVOCATIONS) in;\n";

const glw::GLchar *const GeometryShaderMaxInvocationsTest::m_geometry_shader_code_body =
    "\n"
    "void main()\n"
    "{\n"
    "    float dx = (2.0 / float(GEOMETRY_SHADER_INVOCATIONS));\n"
    "    \n"
    "    gl_Position = vec4(-1.0 + (dx * float(gl_InvocationID)),      -1.001, 0.0, 1.0);\n"
    "    EmitVertex();\n"
    "    \n"
    "    gl_Position = vec4(-1.0 + (dx * float(gl_InvocationID)),       1.001, 0.0, 1.0);\n"
    "    EmitVertex();\n"
    "    \n"
    "    gl_Position = vec4(-1.0 + (dx * float(gl_InvocationID + 1)),   1.001, 0.0, 1.0);\n"
    "    EmitVertex();\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxInvocationsTest */
const glw::GLchar *const GeometryShaderMaxInvocationsTest::m_fragment_shader_code =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "layout(location = 0) out vec4 fs_out_color;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    fs_out_color = vec4(0.0, 1.0, 0.0, 0.0);\n"
    "}\n";

/** ***************************************************************************************************** **/
/* Vertex Shader for GeometryShaderMaxCombinedTextureUnitsTest */
const glw::GLchar *const GeometryShaderMaxCombinedTextureUnitsTest::m_vertex_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "${GPU_SHADER5_ENABLE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "#define NUMBER_OF_POINTS ";

const glw::GLchar *const GeometryShaderMaxCombinedTextureUnitsTest::m_vertex_shader_code_body =
    "u\n"
    "\n"
    "// NUMBER_OF_POINTS == NUMBER_OF_SAMPLERS\n"
    "     uniform highp usampler2D sampler[NUMBER_OF_POINTS];"
    "flat out     int        vs_gs_vertex_id;\n"
    "flat out     uint       vs_gs_sum;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    uint sum = 0u;\n"
    "\n"
    "    for (uint i = 0u; i < uint(gl_VertexID); ++i)\n"
    "    {\n"
    "        sum += texture(sampler[i], vec2(0.0, 0.0)).r;\n"
    "    }\n"
    "\n"
    "    gl_Position     = vec4(-1.0 + ((2.0 / float(NUMBER_OF_POINTS)) * float(gl_VertexID)) + (1.0 / "
    "float(NUMBER_OF_POINTS)), 0, 0, 1.0);\n"
    "    vs_gs_vertex_id = gl_VertexID;\n"
    "    vs_gs_sum       = sum;\n"
    "}\n";

/* Geometry Shader for GeometryShaderMaxCombinedTextureUnitsTest */
const glw::GLchar *const GeometryShaderMaxCombinedTextureUnitsTest::m_geometry_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "${GPU_SHADER5_ENABLE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "layout(points)                   in;\n"
    "layout(points, max_vertices = 1) out;\n"
    "\n"
    "#define NUMBER_OF_POINTS ";

const glw::GLchar *const GeometryShaderMaxCombinedTextureUnitsTest::m_geometry_shader_code_body =
    "u\n"
    "\n"
    "// NUMBER_OF_POINTS == NUMBER_OF_SAMPLERS\n"
    "     uniform highp usampler2D sampler[NUMBER_OF_POINTS];\n"
    "flat in      int        vs_gs_vertex_id[1];\n"
    "flat in      uint       vs_gs_sum      [1];\n"
    "flat out     int        gs_fs_vertex_id;\n"
    "flat out     uint       gs_fs_vertex_sum;\n"
    "flat out     uint       gs_fs_geometry_sum;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    uint sum = 0u;\n"
    "\n"
    "    for (uint i = 0u; i < uint(vs_gs_vertex_id[0]); ++i)\n"
    "    {\n"
    "        sum += texture(sampler[i], vec2(0.0, 0.0)).r;\n"
    "    }\n"
    "\n"
    "    gl_Position        = gl_in[0].gl_Position;\n"
    "    gs_fs_vertex_id    = vs_gs_vertex_id[0];\n"
    "    gs_fs_vertex_sum   = vs_gs_sum      [0];\n"
    "    gs_fs_geometry_sum = sum;\n"
    "    EmitVertex();\n"
    "    EndPrimitive();\n"
    "}\n";

/* Fragment Shader for GeometryShaderMaxCombinedTextureUnitsTest */
const glw::GLchar *const GeometryShaderMaxCombinedTextureUnitsTest::m_fragment_shader_code_preamble =
    "${VERSION}\n"
    "\n"
    "${GEOMETRY_SHADER_REQUIRE}\n"
    "${GPU_SHADER5_ENABLE}\n"
    "\n"
    "precision highp float;\n"
    "\n"
    "// NUMBER_OF_POINTS == NUMBER_OF_SAMPLERS\n"
    "#define NUMBER_OF_POINTS ";

const glw::GLchar *const GeometryShaderMaxCombinedTextureUnitsTest::m_fragment_shader_code_body =
    "u\n"
    "\n"
    "                     uniform highp usampler2D sampler[NUMBER_OF_POINTS];\n"
    "flat                 in      int        gs_fs_vertex_id;\n"
    "flat                 in      uint       gs_fs_vertex_sum;\n"
    "flat                 in      uint       gs_fs_geometry_sum;\n"
    "layout(location = 0) out     uint       fs_out_color;\n"
    "\n"
    "void main()\n"
    "{\n"
    "    uint sum = 0u;\n"
    "\n"
    "    for (uint i = 0u; i < uint(gs_fs_vertex_id); ++i)\n"
    "    {\n"
    "        sum += texture(sampler[i], vec2(0.0, 0.0)).r;\n"
    "    }\n"
    "    fs_out_color = sum + gs_fs_vertex_sum + gs_fs_geometry_sum;\n"
    "}\n";

/** ***************************************************************************************************************** **/

/* Constants for GeometryShaderMaxUniformComponentsTest */
const unsigned int GeometryShaderMaxUniformComponentsTest::m_buffer_size                   = sizeof(glw::GLint);
const glw::GLchar *const GeometryShaderMaxUniformComponentsTest::m_captured_varyings_names = "gs_out_sum";

/* Constants for GeometryShaderMaxUniformBlocksTest */
const unsigned int GeometryShaderMaxUniformBlocksTest::m_buffer_size                   = sizeof(glw::GLint);
const glw::GLchar *const GeometryShaderMaxUniformBlocksTest::m_captured_varyings_names = "gs_out_sum";

/* Constants for GeometryShaderMaxInputComponentsTest */
const unsigned int GeometryShaderMaxInputComponentsTest::m_buffer_size                   = sizeof(glw::GLint);
const glw::GLchar *const GeometryShaderMaxInputComponentsTest::m_captured_varyings_names = "gs_out_sum";

/* Constants for GeometryShaderMaxOutputComponentsTest */
const unsigned int GeometryShaderMaxOutputComponentsTest::m_point_size         = 2;
const unsigned int GeometryShaderMaxOutputComponentsTest::m_texture_height     = m_point_size;
const unsigned int GeometryShaderMaxOutputComponentsTest::m_texture_pixel_size = 4 * sizeof(glw::GLint);

/* Constants for GeometryShaderMaxOutputComponentsSinglePointTest */
const unsigned int GeometryShaderMaxOutputComponentsSinglePointTest::m_point_size         = 2;
const unsigned int GeometryShaderMaxOutputComponentsSinglePointTest::m_texture_height     = m_point_size;
const unsigned int GeometryShaderMaxOutputComponentsSinglePointTest::m_texture_pixel_size = 4 * sizeof(glw::GLint);
const unsigned int GeometryShaderMaxOutputComponentsSinglePointTest::m_texture_width      = m_point_size;

/* Constants for GeometryShaderMaxTextureUnitsTest */
const unsigned int GeometryShaderMaxTextureUnitsTest::m_point_size         = 2;
const unsigned int GeometryShaderMaxTextureUnitsTest::m_texture_height     = m_point_size;
const unsigned int GeometryShaderMaxTextureUnitsTest::m_texture_pixel_size = 4 * sizeof(glw::GLint);

/* Constants for GeometryShaderMaxInvocationsTest */
const unsigned int GeometryShaderMaxInvocationsTest::m_triangle_edge_length = 9;
const unsigned int GeometryShaderMaxInvocationsTest::m_texture_height       = m_triangle_edge_length;
const unsigned int GeometryShaderMaxInvocationsTest::m_texture_pixel_size   = 4 * sizeof(glw::GLubyte);

/* Constants for GeometryShaderMaxCombinedTextureUnitsTest */
const unsigned int GeometryShaderMaxCombinedTextureUnitsTest::m_point_size         = 1;
const unsigned int GeometryShaderMaxCombinedTextureUnitsTest::m_texture_height     = m_point_size;
const unsigned int GeometryShaderMaxCombinedTextureUnitsTest::m_texture_pixel_size = 4 * sizeof(glw::GLint);

/** Constructor
 *
 *  @param context     Test context
 *  @param name        Test case's name
 *  @param description Test case's description
 **/
GeometryShaderLimitsTransformFeedbackBase::GeometryShaderLimitsTransformFeedbackBase(Context &context,
                                                                                     const ExtParameters &extParams,
                                                                                     const char *name,
                                                                                     const char *description)
    : TestCaseBase(context, extParams, name, description)
    , m_fragment_shader_id(0)
    , m_geometry_shader_id(0)
    , m_program_object_id(0)
    , m_vertex_shader_id(0)
    , m_buffer_object_id(0)
    , m_vertex_array_object_id(0)
    , m_fragment_shader_parts(0)
    , m_geometry_shader_parts(0)
    , m_vertex_shader_parts(0)
    , m_n_fragment_shader_parts(0)
    , m_n_geometry_shader_parts(0)
    , m_n_vertex_shader_parts(0)
    , m_captured_varyings_names(0)
    , m_n_captured_varyings(0)
    , m_buffer_size(0)
{
    /* Nothing to be done here */
}

/** Initializes GLES objects used during the test.
 *
 */
void GeometryShaderLimitsTransformFeedbackBase::initTest()
{
    /* This test should only run if EXT_geometry_shader is supported */
    if (!m_is_geometry_shader_extension_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    /* Retrieve ES entrypoints */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Get shaders code from child class */
    getShaderParts(m_fragment_shader_parts, m_n_fragment_shader_parts, m_geometry_shader_parts,
                   m_n_geometry_shader_parts, m_vertex_shader_parts, m_n_vertex_shader_parts);

    /* Get captured varyings from inheriting class */
    getCapturedVaryings(m_captured_varyings_names, m_n_captured_varyings);

    /* Create program and shaders */
    m_program_object_id = gl.createProgram();

    m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER);
    m_geometry_shader_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
    m_vertex_shader_id   = gl.createShader(GL_VERTEX_SHADER);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create program or shader object(s)");

    /* Set up transform feedback */
    gl.transformFeedbackVaryings(m_program_object_id, m_n_captured_varyings, m_captured_varyings_names,
                                 GL_INTERLEAVED_ATTRIBS);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set transform feedback varyings");

    /* Build program */
    if (false == buildProgram(m_program_object_id, m_fragment_shader_id, m_n_fragment_shader_parts,
                              m_fragment_shader_parts, m_geometry_shader_id, m_n_geometry_shader_parts,
                              m_geometry_shader_parts, m_vertex_shader_id, m_n_vertex_shader_parts,
                              m_vertex_shader_parts))
    {
        TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader");
    }

    /* Generate and bind VAO */
    gl.genVertexArrays(1, &m_vertex_array_object_id);
    gl.bindVertexArray(m_vertex_array_object_id);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create vertex array object");

    /* Get size of buffer used by transform feedback from child class */
    getTransformFeedbackBufferSize(m_buffer_size);

    /* Generate, bind and allocate buffer */
    gl.genBuffers(1, &m_buffer_object_id);
    gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer_object_id);
    gl.bufferData(GL_ARRAY_BUFFER, m_buffer_size, 0 /* no start data */, GL_STATIC_COPY);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create buffer object");
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *
 *  Note the function throws exception should an error occur!
 *
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *
 **/
tcu::TestCase::IterateResult GeometryShaderLimitsTransformFeedbackBase::iterate()
{
    initTest();

    /* Retrieve ES entrypoints */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Verification result */
    bool result = false;

    /* Setup transform feedback */
    gl.enable(GL_RASTERIZER_DISCARD);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glEnable(GL_RASTERIZER_DISCARD) call failed");

    gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_buffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed");

    /* Setup draw call */
    gl.useProgram(m_program_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not use program");

    gl.beginTransformFeedback(GL_POINTS);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed");
    {
        /* Let child class prepare input data */
        prepareProgramInput();

        /* Draw */
        gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* one point */);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed");
    }
    /* Stop transform feedback */
    gl.endTransformFeedback();
    GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed");

    /* Map transfrom feedback results */
    const void *transform_feedback_data =
        gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* offset */, m_buffer_size, GL_MAP_READ_BIT);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not map the buffer object into process space");

    /* Verify data extracted from transfrom feedback */
    result = verifyResult(transform_feedback_data);

    /* Unmap transform feedback buffer */
    gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Error unmapping the buffer object");

    /* Let child class clean itself */
    clean();

    /* Verify results */
    if (true != result)
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    }
    else
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }

    return STOP;
}

/** Deinitializes GLES objects created during the test.
 *
 */
void GeometryShaderLimitsTransformFeedbackBase::deinit()
{
    /* Retrieve ES entrypoints */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Bind default values */
    gl.useProgram(0);
    gl.bindVertexArray(0);
    gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0 /* offset */, 0 /* id */);
    gl.bindBuffer(GL_ARRAY_BUFFER, 0);

    /* Delete program object and shaders */
    if (0 != m_program_object_id)
    {
        gl.deleteProgram(m_program_object_id);

        m_program_object_id = 0;
    }

    if (0 != m_fragment_shader_id)
    {
        gl.deleteShader(m_fragment_shader_id);

        m_fragment_shader_id = 0;
    }

    if (0 != m_geometry_shader_id)
    {
        gl.deleteShader(m_geometry_shader_id);

        m_geometry_shader_id = 0;
    }

    if (0 != m_vertex_shader_id)
    {
        gl.deleteShader(m_vertex_shader_id);

        m_vertex_shader_id = 0;
    }

    /* Delete buffer objects */
    if (0 != m_buffer_object_id)
    {
        gl.deleteBuffers(1, &m_buffer_object_id);

        m_buffer_object_id = 0;
    }

    if (0 != m_vertex_array_object_id)
    {
        gl.deleteVertexArrays(1, &m_vertex_array_object_id);

        m_vertex_array_object_id = 0;
    }

    /* Deinitialize base class */
    TestCaseBase::deinit();
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's description
 **/
GeometryShaderLimitsRenderingBase::GeometryShaderLimitsRenderingBase(Context &context, const ExtParameters &extParams,
                                                                     const char *name, const char *description)
    : TestCaseBase(context, extParams, name, description)
    , m_fragment_shader_id(0)
    , m_geometry_shader_id(0)
    , m_program_object_id(0)
    , m_vertex_shader_id(0)
    , m_framebuffer_object_id(0)
    , m_color_texture_id(0)
    , m_vertex_array_object_id(0)
    , m_fragment_shader_parts(0)
    , m_geometry_shader_parts(0)
    , m_vertex_shader_parts(0)
    , m_n_fragment_shader_parts(0)
    , m_n_geometry_shader_parts(0)
    , m_n_vertex_shader_parts(0)
    , m_texture_format(GL_RGBA8)
    , m_texture_height(0)
    , m_texture_pixel_size(0)
    , m_texture_read_format(GL_RGBA)
    , m_texture_read_type(GL_UNSIGNED_BYTE)
    , m_texture_width(0)
{
    /* Nothing to be done here */
}

/** Initializes GLES objects used during the test.
 *
 */
void GeometryShaderLimitsRenderingBase::initTest()
{
    /* This test should only run if EXT_geometry_shader is supported */
    if (!m_is_geometry_shader_extension_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    /* Query on support of EXT_gpu_shader5 */
    if (!m_is_gpu_shader5_supported)
    {
        throw tcu::NotSupportedError(GPU_SHADER5_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Verify that point size range is supported */
    glw::GLfloat point_size_range[2] = {0};
    glw::GLfloat required_point_size = 0.0f;

    if (!glu::isContextTypeES(m_context.getRenderContext().getType()))
    {
        gl.getFloatv(GL_POINT_SIZE_RANGE, point_size_range);
    }
    else
    {
        gl.getFloatv(GL_ALIASED_POINT_SIZE_RANGE, point_size_range);
    }

    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv() call failed");

    getRequiredPointSize(required_point_size);

    if (required_point_size > point_size_range[1])
    {
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Test requires a minimum maximum point size of: " << required_point_size
                           << ", implementation reports a maximum of : " << point_size_range[1]
                           << tcu::TestLog::EndMessage;

        throw tcu::NotSupportedError("Required point size is not supported", "", __FILE__, __LINE__);
    }
    if (!glu::isContextTypeES(m_context.getRenderContext().getType()))
    {
        gl.enable(GL_PROGRAM_POINT_SIZE);
    }

    /* Get shaders code from child class */
    getShaderParts(m_fragment_shader_parts, m_n_fragment_shader_parts, m_geometry_shader_parts,
                   m_n_geometry_shader_parts, m_vertex_shader_parts, m_n_vertex_shader_parts);

    /* Create program and shaders */
    m_program_object_id = gl.createProgram();

    m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER);
    m_geometry_shader_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
    m_vertex_shader_id   = gl.createShader(GL_VERTEX_SHADER);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create program or shader object(s)");

    /* Build program */
    if (false == buildProgram(m_program_object_id, m_fragment_shader_id, m_n_fragment_shader_parts,
                              m_fragment_shader_parts, m_geometry_shader_id, m_n_geometry_shader_parts,
                              m_geometry_shader_parts, m_vertex_shader_id, m_n_vertex_shader_parts,
                              m_vertex_shader_parts))
    {
        TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader");
    }

    /* Set up a vertex array object */
    gl.genVertexArrays(1, &m_vertex_array_object_id);
    gl.bindVertexArray(m_vertex_array_object_id);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create vertex array object");

    /* Get framebuffer details */
    getFramebufferDetails(m_texture_format, m_texture_read_format, m_texture_read_type, m_texture_width,
                          m_texture_height, m_texture_pixel_size);

    /* Set up texture object and a FBO */
    gl.genTextures(1, &m_color_texture_id);
    gl.genFramebuffers(1, &m_framebuffer_object_id);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create framebuffer");

    if (false == setupFramebufferWithTextureAsAttachment(m_framebuffer_object_id, m_color_texture_id, m_texture_format,
                                                         m_texture_width, m_texture_height))
    {
        TCU_FAIL("Failed to setup framebuffer");
    }
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *
 *  Note the function throws exception should an error occur!
 *
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *
 **/
tcu::TestCase::IterateResult GeometryShaderLimitsRenderingBase::iterate()
{
    initTest();

    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Variables used for image verification purposes */
    std::vector<unsigned char> result_image(m_texture_width * m_texture_height * m_texture_pixel_size);

    /* Render */
    gl.useProgram(m_program_object_id);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not use program");

    /* Let child class prepare input for program */
    prepareProgramInput();

    gl.clearColor(0 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */);
    gl.clear(GL_COLOR_BUFFER_BIT);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not clear the color buffer");

    /* Get draw call details from child class */
    glw::GLenum primitive_type = GL_POINTS;
    glw::GLuint n_vertices     = 1;

    getDrawCallDetails(primitive_type, n_vertices);

    gl.drawArrays(primitive_type, 0 /* first */, n_vertices);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed");

    /* Extract image from FBO */
    gl.readPixels(0 /* x */, 0 /* y */, m_texture_width, m_texture_height, m_texture_read_format, m_texture_read_type,
                  &result_image[0]);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not read back pixels from color buffer");

    /* Run verification */
    if (true == verifyResult(&result_image[0]))
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }
    else
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    }

    /* Let child class clean itself */
    clean();

    return STOP;
}

/** Deinitializes GLES objects created during the test.
 *
 */
void GeometryShaderLimitsRenderingBase::deinit()
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Reset OpenGL ES state */
    gl.useProgram(0);
    gl.bindVertexArray(0);
    gl.bindTexture(GL_TEXTURE_2D, 0);
    gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
    if (!glu::isContextTypeES(m_context.getRenderContext().getType()))
    {
        gl.disable(GL_PROGRAM_POINT_SIZE);
    }

    /* Delete program object and shaders */
    if (m_program_object_id != 0)
    {
        gl.deleteProgram(m_program_object_id);

        m_program_object_id = 0;
    }

    if (m_fragment_shader_id != 0)
    {
        gl.deleteShader(m_fragment_shader_id);

        m_fragment_shader_id = 0;
    }

    if (m_geometry_shader_id != 0)
    {
        gl.deleteShader(m_geometry_shader_id);

        m_geometry_shader_id = 0;
    }

    if (m_vertex_shader_id != 0)
    {
        gl.deleteShader(m_vertex_shader_id);

        m_vertex_shader_id = 0;
    }

    /* Delete frambuffer and textures */
    if (m_framebuffer_object_id != 0)
    {
        gl.deleteFramebuffers(1, &m_framebuffer_object_id);

        m_framebuffer_object_id = 0;
    }

    if (m_color_texture_id != 0)
    {
        gl.deleteTextures(1, &m_color_texture_id);

        m_color_texture_id = 0;
    }

    if (m_vertex_array_object_id != 0)
    {
        gl.deleteVertexArrays(1, &m_vertex_array_object_id);

        m_vertex_array_object_id = 0;
    }

    /* Deinitialize base class */
    TestCaseBase::deinit();
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's description
 **/
GeometryShaderMaxUniformComponentsTest::GeometryShaderMaxUniformComponentsTest(Context &context,
                                                                               const ExtParameters &extParams,
                                                                               const char *name,
                                                                               const char *description)
    : GeometryShaderLimitsTransformFeedbackBase(context, extParams, name, description)
    , m_max_uniform_components(0)
    , m_max_uniform_vectors(0)
    , m_uniform_location(0)
{
    /* Nothing to be done here */
}

/** Clears data after draw call and result verification
 *
 **/
void GeometryShaderMaxUniformComponentsTest::clean()
{
    m_uniform_data.clear();
}

/** Get names and number of varyings to be captured by transform feedback
 *
 *  @param out_captured_varyings_names Array of varying names
 *  @param out_n_captured_varyings     Number of varying names
 **/
void GeometryShaderMaxUniformComponentsTest::getCapturedVaryings(const glw::GLchar *const *&out_captured_varyings_names,
                                                                 glw::GLuint &out_n_captured_varyings)
{
    /* Varying names */
    out_captured_varyings_names = &m_captured_varyings_names;

    /* Number of varyings */
    out_n_captured_varyings = 1;
}

/** Get parts of shaders
 *
 *  @param out_fragment_shader_parts   Array of fragment shader parts
 *  @param out_n_fragment_shader_parts Number of fragment shader parts
 *  @param out_geometry_shader_parts   Array of geometry shader parts
 *  @param out_n_geometry_shader_parts Number of geometry shader parts
 *  @param out_vertex_shader_parts     Array of vertex shader parts
 *  @param out_n_vertex_shader_parts   Number of vertex shader parts
 **/
void GeometryShaderMaxUniformComponentsTest::getShaderParts(const glw::GLchar *const *&out_fragment_shader_parts,
                                                            unsigned int &out_n_fragment_shader_parts,
                                                            const glw::GLchar *const *&out_geometry_shader_parts,
                                                            unsigned int &out_n_geometry_shader_parts,
                                                            const glw::GLchar *const *&out_vertex_shader_parts,
                                                            unsigned int &out_n_vertex_shader_parts)
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Fragment Shader */
    out_fragment_shader_parts   = &m_fragment_shader_code;
    out_n_fragment_shader_parts = 1;

    /* Get maximum number of uniform */
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_UNIFORM_COMPONENTS, &m_max_uniform_components);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT pname.");

    m_max_uniform_vectors = m_max_uniform_components / 4 /* 4 components per vector */;

    std::stringstream stream;
    stream << m_max_uniform_vectors;
    m_max_uniform_vectors_string = stream.str();

    /* Geometry Shader */
    m_geometry_shader_parts[0] = m_geometry_shader_code_preamble;
    m_geometry_shader_parts[1] = m_geometry_shader_code_number_of_uniforms;
    m_geometry_shader_parts[2] = m_max_uniform_vectors_string.c_str();
    m_geometry_shader_parts[3] = m_geometry_shader_code_body;

    out_geometry_shader_parts   = m_geometry_shader_parts;
    out_n_geometry_shader_parts = 4;

    /* Vertex Shader */
    out_vertex_shader_parts   = &m_vertex_shader_code;
    out_n_vertex_shader_parts = 1;
}

/** Get size of buffer used by transform feedback
 *
 *  @param out_buffer_size Size of buffer in bytes
 **/
void GeometryShaderMaxUniformComponentsTest::getTransformFeedbackBufferSize(unsigned int &out_buffer_size)
{
    out_buffer_size = m_buffer_size;
}

/** Prepare test specific program input for draw call
 *
 **/
void GeometryShaderMaxUniformComponentsTest::prepareProgramInput()
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Uniform location */
    m_uniform_location = gl.getUniformLocation(m_program_object_id, "uni_array");

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to get uniform location");

    if (-1 == m_uniform_location)
    {
        TCU_FAIL("Invalid uniform location");
    }

    /* 3. Configure the uniforms to use subsequently increasing values, starting
     *  from 1 for R component of first vector, 2 for G component of that vector,
     *  5 for first component of second vector, and so on.
     **/
    m_uniform_data.resize(m_max_uniform_components);

    for (glw::GLint i = 0; i < m_max_uniform_components; ++i)
    {
        m_uniform_data[i] = i + 1;
    }

    /* Set uniform data */
    gl.uniform4iv(m_uniform_location, m_max_uniform_vectors, &m_uniform_data[0]);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set uniform data");
}

/** Verification of results
 *
 *  @param result Pointer to data mapped from transform feedback buffer.
 (                Size of data is equal to buffer_size set by getTransformFeedbackBufferSize()
 *
 *  @return true  Result matches expected value
 *          false Result has wrong value
 **/
bool GeometryShaderMaxUniformComponentsTest::verifyResult(const void *data)
{
    /* Expected data, sum of elements in range <x;y> with length n = ((x + y) / 2) * n */
    const glw::GLint expected_data = ((1 + m_max_uniform_components) * m_max_uniform_components) / 2;

    /* Cast to const GLint */
    const glw::GLint *transform_feedback_data = (const glw::GLint *)data;

    /* Verify data extracted from transfrom feedback */
    if (0 != memcmp(transform_feedback_data, &expected_data, m_buffer_size))
    {
        m_testCtx.getLog() << tcu::TestLog::Message << "Wrong result! Expected: " << expected_data
                           << " Extracted: " << *transform_feedback_data << tcu::TestLog::EndMessage;

        return false;
    }
    else
    {
        return true;
    }
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's description
 **/
GeometryShaderMaxUniformBlocksTest::GeometryShaderMaxUniformBlocksTest(Context &context, const ExtParameters &extParams,
                                                                       const char *name, const char *description)
    : GeometryShaderLimitsTransformFeedbackBase(context, extParams, name, description)
    , m_max_uniform_blocks(0)
{
    /* Nothing to be done here */
}

/** Clears data after draw call and result verification
 *
 **/
void GeometryShaderMaxUniformBlocksTest::clean()
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Bind default to uniform binding point */
    gl.bindBuffer(GL_UNIFORM_BUFFER, 0);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed");

    /* Release buffers */
    for (glw::GLint i = 0; i < m_max_uniform_blocks; ++i)
    {
        /* Bind default to uniform block */
        gl.bindBufferBase(GL_UNIFORM_BUFFER, i, 0);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed");

        /* Delete buffer */
        gl.deleteBuffers(1, &m_uniform_blocks[i].buffer_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers() call failed");
    }

    /* Free memory */
    m_uniform_blocks.clear();
}

/** Get names and number of varyings to be captured by transform feedback
 *
 *  @param out_captured_varyings_names Array of varying names
 *  @param out_n_captured_varyings     Number of varying names
 **/
void GeometryShaderMaxUniformBlocksTest::getCapturedVaryings(const glw::GLchar *const *&out_captured_varyings_names,
                                                             glw::GLuint &out_n_captured_varyings)
{
    /* Varying names */
    out_captured_varyings_names = &m_captured_varyings_names;

    /* Number of varyings */
    out_n_captured_varyings = 1;
}

/** Get parts of shaders
 *
 *  @param out_fragment_shader_parts   Array of fragment shader parts
 *  @param out_n_fragment_shader_parts Number of fragment shader parts
 *  @param out_geometry_shader_parts   Array of geometry shader parts
 *  @param out_n_geometry_shader_parts Number of geometry shader parts
 *  @param out_vertex_shader_parts     Array of vertex shader parts
 *  @param out_n_vertex_shader_parts   Number of vertex shader parts
 **/
void GeometryShaderMaxUniformBlocksTest::getShaderParts(const glw::GLchar *const *&out_fragment_shader_parts,
                                                        unsigned int &out_n_fragment_shader_parts,
                                                        const glw::GLchar *const *&out_geometry_shader_parts,
                                                        unsigned int &out_n_geometry_shader_parts,
                                                        const glw::GLchar *const *&out_vertex_shader_parts,
                                                        unsigned int &out_n_vertex_shader_parts)
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Fragment Shader */
    out_fragment_shader_parts   = &m_fragment_shader_code;
    out_n_fragment_shader_parts = 1;

    /* Get maximum number of uniform blocks */
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_UNIFORM_BLOCKS, &m_max_uniform_blocks);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed for GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT");

    std::stringstream stream;
    stream << m_max_uniform_blocks;
    m_max_uniform_blocks_string = stream.str();

    /* Geometry Shader */
    m_geometry_shader_parts[0] = m_geometry_shader_code_preamble;
    m_geometry_shader_parts[1] = m_geometry_shader_code_number_of_uniforms;
    m_geometry_shader_parts[2] = m_max_uniform_blocks_string.c_str();
    m_geometry_shader_parts[3] = m_geometry_shader_code_body_str;

    stream.str(std::string());
    stream.clear();
    for (glw::GLint uniform_block_nr = 0; uniform_block_nr < m_max_uniform_blocks; ++uniform_block_nr)
    {
        stream << "    gs_out_sum += uni_block_array[" << uniform_block_nr << "].entry;\n";
    }
    m_uniform_block_access_string = stream.str();

    m_geometry_shader_parts[4] = m_uniform_block_access_string.c_str();
    m_geometry_shader_parts[5] = m_geometry_shader_code_body_end;

    out_geometry_shader_parts   = m_geometry_shader_parts;
    out_n_geometry_shader_parts = 6;

    /* Vertex Shader */
    out_vertex_shader_parts   = &m_vertex_shader_code;
    out_n_vertex_shader_parts = 1;
}

/** Get size of buffer used by transform feedback
 *
 *  @param out_buffer_size Size of buffer in bytes
 **/
void GeometryShaderMaxUniformBlocksTest::getTransformFeedbackBufferSize(unsigned int &out_buffer_size)
{
    out_buffer_size = m_buffer_size;
}

/** Prepare test specific program input for draw call
 *
 **/
void GeometryShaderMaxUniformBlocksTest::prepareProgramInput()
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Allocate memory */
    m_uniform_blocks.resize(m_max_uniform_blocks);

    /* Setup uniform blocks */
    for (glw::GLint i = 0; i < m_max_uniform_blocks; ++i)
    {
        /* Generate and bind */
        gl.genBuffers(1, &m_uniform_blocks[i].buffer_object_id);
        gl.bindBuffer(GL_UNIFORM_BUFFER, m_uniform_blocks[i].buffer_object_id);

        GLU_EXPECT_NO_ERROR(gl.getError(), "Failed create buffer object");

        /** Expected data is range <1;GL_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT>
         *  See test description for details
         **/
        m_uniform_blocks[i].data = i + 1;

        gl.bufferData(GL_UNIFORM_BUFFER, sizeof(glw::GLint), &m_uniform_blocks[i].data, GL_STATIC_DRAW);
        GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set buffer data");

        /* Bind buffer to uniform block */
        gl.bindBufferBase(GL_UNIFORM_BUFFER, i, m_uniform_blocks[i].buffer_object_id);
        GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to bind buffer to uniform block");
    }
}

/** Verification of results
 *
 *  @param result Pointer to data mapped from transform feedback buffer.
 *                Size of data is equal to buffer_size set by getTransformFeedbackBufferSize()
 *
 *  @return true  Result match expected value
 *          false Result has wrong value
 **/
bool GeometryShaderMaxUniformBlocksTest::verifyResult(const void *data)
{
    /* Expected data, sum of elements in range <x;y> with length n = ((x + y) / 2) * n */
    const glw::GLint expected_data = ((1 + m_max_uniform_blocks) * m_max_uniform_blocks) / 2;

    /* Cast to const GLint */
    const glw::GLint *transform_feedback_data = (const glw::GLint *)data;

    /* Verify data extracted from transfrom feedback */
    if (0 != memcmp(transform_feedback_data, &expected_data, m_buffer_size))
    {
        m_testCtx.getLog() << tcu::TestLog::Message << "Wrong result! Expected: " << expected_data
                           << " Extracted: " << *transform_feedback_data << tcu::TestLog::EndMessage;

        return false;
    }
    else
    {
        return true;
    }
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's description
 **/
GeometryShaderMaxInputComponentsTest::GeometryShaderMaxInputComponentsTest(Context &context,
                                                                           const ExtParameters &extParams,
                                                                           const char *name, const char *description)
    : GeometryShaderLimitsTransformFeedbackBase(context, extParams, name, description)
    , m_max_geometry_input_components(0)
    , m_max_geometry_input_vectors(0)
{
    /* Nothing to be done here */
}

/** Clears data after draw call and result verification
 *
 **/
void GeometryShaderMaxInputComponentsTest::clean()
{
    /* Nothing to be done here */
}

/** Get names and number of varyings to be captured by transform feedback
 *
 *  @param out_captured_varyings_names Array of varying names
 *  @param out_n_captured_varyings     Number of varying names
 **/
void GeometryShaderMaxInputComponentsTest::getCapturedVaryings(const glw::GLchar *const *&out_captured_varyings_names,
                                                               glw::GLuint &out_n_captured_varyings)
{
    /* Varying names */
    out_captured_varyings_names = &m_captured_varyings_names;

    /* Number of varyings */
    out_n_captured_varyings = 1;
}

/** Get parts of shaders
 *
 *  @param out_fragment_shader_parts   Array of fragment shader parts
 *  @param out_n_fragment_shader_parts Number of fragment shader parts
 *  @param out_geometry_shader_parts   Array of geometry shader parts
 *  @param out_n_geometry_shader_parts Number of geometry shader parts
 *  @param out_vertex_shader_parts     Array of vertex shader parts
 *  @param out_n_vertex_shader_parts   Number of vertex shader parts
 **/
void GeometryShaderMaxInputComponentsTest::getShaderParts(const glw::GLchar *const *&out_fragment_shader_parts,
                                                          unsigned int &out_n_fragment_shader_parts,
                                                          const glw::GLchar *const *&out_geometry_shader_parts,
                                                          unsigned int &out_n_geometry_shader_parts,
                                                          const glw::GLchar *const *&out_vertex_shader_parts,
                                                          unsigned int &out_n_vertex_shader_parts)
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Fragment Shader */
    out_fragment_shader_parts   = &m_fragment_shader_code;
    out_n_fragment_shader_parts = 1;

    /* Get maximum number of uniform */
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_INPUT_COMPONENTS, &m_max_geometry_input_components);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_INPUT_COMPONENTS_EXT pname");

    m_max_geometry_input_vectors = m_max_geometry_input_components / 4 /* 4 components per vector */;

    std::stringstream stream;
    stream << m_max_geometry_input_vectors;
    m_max_geometry_input_vectors_string = stream.str();

    /* Geometry Shader */
    m_geometry_shader_parts[0] = m_geometry_shader_code_preamble;
    m_geometry_shader_parts[1] = m_geometry_shader_code_number_of_uniforms;
    m_geometry_shader_parts[2] = m_max_geometry_input_vectors_string.c_str();
    m_geometry_shader_parts[3] = m_geometry_shader_code_body;

    out_geometry_shader_parts   = m_geometry_shader_parts;
    out_n_geometry_shader_parts = 4;

    /* Vertex Shader */
    m_vertex_shader_parts[0] = m_vertex_shader_code_preamble;
    m_vertex_shader_parts[1] = m_vertex_shader_code_number_of_uniforms;
    m_vertex_shader_parts[2] = m_max_geometry_input_vectors_string.c_str();
    m_vertex_shader_parts[3] = m_vertex_shader_code_body;

    out_vertex_shader_parts   = m_vertex_shader_parts;
    out_n_vertex_shader_parts = 4;
}

/** Get size of buffer used by transform feedback
 *
 *  @param out_buffer_size  Size of buffer in bytes
 **/
void GeometryShaderMaxInputComponentsTest::getTransformFeedbackBufferSize(unsigned int &out_buffer_size)
{
    out_buffer_size = m_buffer_size;
}

/** Prepare test specific program input for draw call
 *
 **/
void GeometryShaderMaxInputComponentsTest::prepareProgramInput()
{
    /* Nothing to be done here */
}

/** Verification of results
 *
 *  @param result Pointer to data mapped from transform feedback buffer.
 *                Size of data is equal to buffer_size set by getTransformFeedbackBufferSize()
 *
 *  @return true  Result match expected value
 *          false Result has wrong value
 **/
bool GeometryShaderMaxInputComponentsTest::verifyResult(const void *data)
{
    /* Expected data, sum of elements in range <x;y> with length n = ((x + y) / 2) * n */
    const glw::GLint expected_data = ((1 + m_max_geometry_input_components) * m_max_geometry_input_components) / 2;

    /* Cast to const GLint */
    const glw::GLint *transform_feedback_data = (const glw::GLint *)data;

    /* Verify data extracted from transfrom feedback */
    if (0 != memcmp(transform_feedback_data, &expected_data, m_buffer_size))
    {
        m_testCtx.getLog() << tcu::TestLog::Message << "Wrong result! Expected: " << expected_data
                           << " Extracted: " << *transform_feedback_data << tcu::TestLog::EndMessage;

        return false;
    }
    else
    {
        return true;
    }
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's description
 **/
GeometryShaderMaxOutputComponentsTest::GeometryShaderMaxOutputComponentsTest(Context &context,
                                                                             const ExtParameters &extParams,
                                                                             const char *name, const char *description)
    : GeometryShaderLimitsRenderingBase(context, extParams, name, description)
    , m_fragment_shader_code_c_str(0)
    , m_geometry_shader_code_c_str(0)
    , m_texture_width(0)
    , m_max_output_components(0)
    , m_max_output_vectors(0)
    , m_max_total_output_components(0)
    , m_n_available_vectors(0)
    , m_n_output_points(0)
{
    /* Nothing to be done here */
}

/** Clears data after draw call and result verification
 *
 **/
void GeometryShaderMaxOutputComponentsTest::clean()
{
    /* Nothing to be done here */
}

/** Get details for draw call
 *
 *  @param out_primitive_type Type of primitive that will be used by next draw call
 *  @param out_n_vertices     Number of vertices that will used with next draw call
 **/
void GeometryShaderMaxOutputComponentsTest::getDrawCallDetails(glw::GLenum &out_primitive_type,
                                                               glw::GLuint &out_n_vertices)
{
    /* Draw one point */
    out_primitive_type = GL_POINTS;
    out_n_vertices     = 1;
}

/** Get dimensions and format for texture bind to color attachment 0, get format and type for glReadPixels
 *
 *  @param out_texture_format      Format for texture used as color attachment 0
 *  @param out_texture_read_format Format of data used with glReadPixels
 *  @param out_texture_read_type   Type of data used with glReadPixels
 *  @param out_texture_width       Width of texture used as color attachment 0
 *  @param out_texture_height      Height of texture used as color attachment 0
 *  @param out_texture_pixel_size  Size of single pixel in bytes
 **/
void GeometryShaderMaxOutputComponentsTest::getFramebufferDetails(
    glw::GLenum &out_texture_format, glw::GLenum &out_texture_read_format, glw::GLenum &out_texture_read_type,
    glw::GLuint &out_texture_width, glw::GLuint &out_texture_height, unsigned int &out_texture_pixel_size)
{
    out_texture_format      = GL_R32I;
    out_texture_read_format = GL_RGBA_INTEGER;
    out_texture_read_type   = GL_INT;
    out_texture_width       = m_texture_width;
    out_texture_height      = m_texture_height;
    out_texture_pixel_size  = 4 * 4;
}

void GeometryShaderMaxOutputComponentsTest::getRequiredPointSize(glw::GLfloat &out_point_size)
{
    /* This test should only run if EXT_geometry_point_size is supported */
    if (!m_is_geometry_shader_point_size_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_POINT_SIZE_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    out_point_size = (float)m_point_size;
}

/** Get parts of shaders
 *
 *  @param out_fragment_shader_parts   Array of fragment shader parts
 *  @param out_n_fragment_shader_parts Number of fragment shader parts
 *  @param out_geometry_shader_parts   Array of geometry shader parts
 *  @param out_n_geometry_shader_parts Number of geometry shader parts
 *  @param out_vertex_shader_parts     Array of vertex shader parts
 *  @param out_n_vertex_shader_parts   Number of vertex shader parts
 **/
void GeometryShaderMaxOutputComponentsTest::getShaderParts(const glw::GLchar *const *&out_fragment_shader_parts,
                                                           unsigned int &out_n_fragment_shader_parts,
                                                           const glw::GLchar *const *&out_geometry_shader_parts,
                                                           unsigned int &out_n_geometry_shader_parts,
                                                           const glw::GLchar *const *&out_vertex_shader_parts,
                                                           unsigned int &out_n_vertex_shader_parts)
{
    /* GL functions */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Get maximum number of output components */
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, &m_max_total_output_components);
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_OUTPUT_COMPONENTS, &m_max_output_components);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call(s) failed");

    m_n_output_points     = m_max_total_output_components / m_max_output_components;
    m_max_output_vectors  = m_max_output_components / 4; /* 4 components per vector */
    m_n_available_vectors = m_max_output_vectors - 2;    /* 2 vectors are reserved for gl_Position and gl_PointSize */

    /* Framebuffer width */
    m_texture_width = m_point_size * m_n_output_points;

    /* Fragment shader parts */
    prepareFragmentShader(m_fragment_shader_code);

    m_fragment_shader_code_c_str = m_fragment_shader_code.c_str();
    out_fragment_shader_parts    = &m_fragment_shader_code_c_str;
    out_n_fragment_shader_parts  = 1;

    /* Geometry shader parts */
    prepareGeometryShader(m_geometry_shader_code);

    m_geometry_shader_code_c_str = m_geometry_shader_code.c_str();
    out_geometry_shader_parts    = &m_geometry_shader_code_c_str;
    out_n_geometry_shader_parts  = 1;

    /* Vertex shader */
    out_vertex_shader_parts   = &m_vertex_shader_code;
    out_n_vertex_shader_parts = 1;
}

/** Prepare test specific program input for draw call
 *
 **/
void GeometryShaderMaxOutputComponentsTest::prepareProgramInput()
{
    /* Nothing to be done here */
}

/** Verify rendered image
 *
 *  @param data Image to verify
 *
 *  @return true  Image pixels match expected values
 *          false Some pixels have wrong values
 **/
bool GeometryShaderMaxOutputComponentsTest::verifyResult(const void *data)
{
    const unsigned char *result_image       = (const unsigned char *)data;
    const unsigned int line_size            = m_texture_width * m_texture_pixel_size;
    const glw::GLint n_components_per_point = m_n_available_vectors * 4; /* 4 components per vector */

    /* For each drawn point */
    for (glw::GLint point = 0; point < m_n_output_points; ++point)
    {
        const glw::GLint first_value    = point * n_components_per_point + 1;
        const glw::GLint last_value     = (point + 1) * n_components_per_point;
        const glw::GLint expected_value = ((first_value + last_value) * n_components_per_point) / 2;
        const unsigned int point_offset = point * m_texture_pixel_size * m_point_size;

        /* Verify all pixels that belong to point, area m_point_size x m_point_size */
        for (unsigned int y = 0; y < m_point_size; ++y)
        {
            const unsigned int line_offset        = y * line_size;
            const unsigned int first_texel_offset = line_offset + point_offset;

            for (unsigned int x = 0; x < m_point_size; ++x)
            {
                const unsigned int texel_offset = first_texel_offset + x * m_texture_pixel_size;

                if (0 != memcmp(result_image + texel_offset, &expected_value, sizeof(expected_value)))
                {
                    glw::GLint *result_value = (glw::GLint *)(result_image + texel_offset);

                    m_testCtx.getLog() << tcu::TestLog::Message << "Wrong result! Expected: " << expected_value
                                       << " Extracted: " << *result_value << " Point: " << point << " X: " << x
                                       << " Y: " << y << tcu::TestLog::EndMessage;

                    return false;
                }
            }
        }
    }

    return true;
}

/** Prepare fragment shader code
 *
 *  @param out_shader_code String that will be used to store shaders code
 **/
void GeometryShaderMaxOutputComponentsTest::prepareFragmentShader(std::string &out_shader_code) const
{
    std::stringstream stream;

    stream << m_fragment_shader_code_preamble;
    stream << m_common_shader_code_gs_fs_out_definitions;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << m_fragment_shader_code_flat_in_ivec4 << " " << m_common_shader_code_gs_fs_out << i << ";\n";
    }

    stream << m_fragment_shader_code_body_begin;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << "    " << m_fragment_shader_code_sum << m_common_shader_code_gs_fs_out << i << ".x + "
               << m_common_shader_code_gs_fs_out << i << ".y + " << m_common_shader_code_gs_fs_out << i << ".z + "
               << m_common_shader_code_gs_fs_out << i << ".w;\n";
    }

    stream << m_fragment_shader_code_body_end;

    out_shader_code = stream.str();
}

/** Prepare geometry shader code
 *
 *  @param out_shader_code String that will be used to store shaders code
 **/
void GeometryShaderMaxOutputComponentsTest::prepareGeometryShader(std::string &out_shader_code) const
{
    std::stringstream stream;

    stream << m_geometry_shader_code_preamble;
    stream << m_common_shader_code_number_of_points;
    stream << m_n_output_points;
    stream << m_geometry_shader_code_layout;
    stream << m_common_shader_code_gs_fs_out_definitions;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << m_geometry_shader_code_flat_out_ivec4 << " " << m_common_shader_code_gs_fs_out << i << ";\n";
    }

    stream << m_geometry_shader_code_body_begin;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << "        " << m_common_shader_code_gs_fs_out << i << m_geometry_shader_code_assignment;
    }

    stream << m_geometry_shader_code_body_end;

    out_shader_code = stream.str();
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's description
 **/
GeometryShaderMaxOutputVerticesTest::GeometryShaderMaxOutputVerticesTest(Context &context,
                                                                         const ExtParameters &extParams,
                                                                         const char *name, const char *description)
    : TestCaseBase(context, extParams, name, description)
{
    /* Nothing to be done here */
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *
 *  Note the function throws exception should an error occur!
 *
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *
 **/
tcu::TestCase::IterateResult GeometryShaderMaxOutputVerticesTest::iterate()
{
    /* This test should only run if EXT_geometry_shader is supported */
    if (!m_is_geometry_shader_extension_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    /* GL */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Get maximum number of output vertices and prepare strings */
    glw::GLint max_output_vertices;
    std::string valid_output_vertices_string;
    std::string invalid_output_vertices_string;

    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_OUTPUT_VERTICES, &max_output_vertices);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed for GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT pname");

    std::stringstream stream_valid;
    stream_valid << max_output_vertices;
    valid_output_vertices_string = stream_valid.str();

    std::stringstream stream_invalid;
    stream_invalid << max_output_vertices + 1;
    invalid_output_vertices_string = stream_invalid.str();

    /* Geometry shader parts */
    const glw::GLchar *geometry_shader_valid_parts[] = {
        m_geometry_shader_code_preamble, valid_output_vertices_string.c_str(), m_geometry_shader_code_body};

    const glw::GLchar *geometry_shader_invalid_parts[] = {
        m_geometry_shader_code_preamble, invalid_output_vertices_string.c_str(), m_geometry_shader_code_body};

    /* Try to build programs */
    bool does_valid_build =
        doesProgramBuild(1, &m_fragment_shader_code, 3, geometry_shader_valid_parts, 1, &m_vertex_shader_code);

    bool does_invalid_build =
        doesProgramBuild(1, &m_fragment_shader_code, 3, geometry_shader_invalid_parts, 1, &m_vertex_shader_code);

    /* Verify results */
    if ((true == does_valid_build) && (false == does_invalid_build))
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }
    else
    {
        if (true != does_valid_build)
        {
            m_testCtx.getLog() << tcu::TestLog::Message
                               << "Failed to build valid program! GS::max_vertices "
                                  "set to MAX_GEOMETRY_OUTPUT_VERTICES.\n"
                               << tcu::TestLog::EndMessage;
        }

        if (false != does_invalid_build)
        {
            m_testCtx.getLog() << tcu::TestLog::Message
                               << "Build of invalid program was successful! GS::max_vertices "
                                  "set to MAX_GEOMETRY_OUTPUT_VERTICES + 1.\n"
                               << tcu::TestLog::EndMessage;
        }

        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    }

    return STOP;
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's decsription
 **/
GeometryShaderMaxOutputComponentsSinglePointTest::GeometryShaderMaxOutputComponentsSinglePointTest(
    Context &context, const ExtParameters &extParams, const char *name, const char *description)
    : GeometryShaderLimitsRenderingBase(context, extParams, name, description)
    , m_fragment_shader_code_c_str(0)
    , m_geometry_shader_code_c_str(0)
    , m_max_output_components(0)
    , m_max_output_vectors(0)
    , m_n_available_vectors(0)
{
    /* Nothing to be done here */
}

/** Clears data after draw call and result verification
 *
 **/
void GeometryShaderMaxOutputComponentsSinglePointTest::clean()
{
    /* Nothing to be done here */
}

/** Get details for draw call
 *
 *  @param out_primitive_type Type of primitive that will be used by next draw call
 *  @param out_n_vertices     Number of vertices that will used with next draw call
 **/
void GeometryShaderMaxOutputComponentsSinglePointTest::getDrawCallDetails(glw::GLenum &out_primitive_type,
                                                                          glw::GLuint &out_n_vertices)
{
    /* Draw one point */
    out_primitive_type = GL_POINTS;
    out_n_vertices     = 1;
}

/** Get dimensions and format for texture bind to color attachment 0, get format and type for glReadPixels
 *
 *  @param out_texture_format      Format for texture used as color attachment 0
 *  @param out_texture_read_format Format of data used with glReadPixels
 *  @param out_texture_read_type   Type of data used with glReadPixels
 *  @param out_texture_width       Width of texture used as color attachment 0
 *  @param out_texture_height      Height of texture used as color attachment 0
 *  @param out_texture_pixel_size  Size of single pixel in bytes
 **/
void GeometryShaderMaxOutputComponentsSinglePointTest::getFramebufferDetails(
    glw::GLenum &out_texture_format, glw::GLenum &out_texture_read_format, glw::GLenum &out_texture_read_type,
    glw::GLuint &out_texture_width, glw::GLuint &out_texture_height, unsigned int &out_texture_pixel_size)
{
    out_texture_format      = GL_R32I;
    out_texture_read_format = GL_RGBA_INTEGER;
    out_texture_read_type   = GL_INT;
    out_texture_width       = m_texture_width;
    out_texture_height      = m_texture_height;
    out_texture_pixel_size  = 4 * 4;
}

void GeometryShaderMaxOutputComponentsSinglePointTest::getRequiredPointSize(glw::GLfloat &out_point_size)
{
    /* This test should only run if EXT_geometry_point_size is supported */
    if (!m_is_geometry_shader_point_size_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_POINT_SIZE_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    out_point_size = (float)m_point_size;
}

/** Get parts of shaders
 *
 *  @param out_fragment_shader_parts   Array of fragment shader parts
 *  @param out_n_fragment_shader_parts Number of fragment shader parts
 *  @param out_geometry_shader_parts   Array of geometry shader parts
 *  @param out_n_geometry_shader_parts Number of geometry shader parts
 *  @param out_vertex_shader_parts     Array of vertex shader parts
 *  @param out_n_vertex_shader_parts   Number of vertex shader parts
 **/
void GeometryShaderMaxOutputComponentsSinglePointTest::getShaderParts(
    const glw::GLchar *const *&out_fragment_shader_parts, unsigned int &out_n_fragment_shader_parts,
    const glw::GLchar *const *&out_geometry_shader_parts, unsigned int &out_n_geometry_shader_parts,
    const glw::GLchar *const *&out_vertex_shader_parts, unsigned int &out_n_vertex_shader_parts)
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Get maximum number of output components */
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_OUTPUT_COMPONENTS, &m_max_output_components);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed for GL_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT pname");

    m_max_output_vectors  = m_max_output_components / 4; /* 4 components per vector */
    m_n_available_vectors = m_max_output_vectors - 2;    /* 2 vectors are reserved for gl_Position and gl_PointSize */

    /* Fragment shader parts */
    prepareFragmentShader(m_fragment_shader_code);

    m_fragment_shader_code_c_str = m_fragment_shader_code.c_str();
    out_fragment_shader_parts    = &m_fragment_shader_code_c_str;
    out_n_fragment_shader_parts  = 1;

    /* Geometry shader parts */
    prepareGeometryShader(m_geometry_shader_code);

    m_geometry_shader_code_c_str = m_geometry_shader_code.c_str();
    out_geometry_shader_parts    = &m_geometry_shader_code_c_str;
    out_n_geometry_shader_parts  = 1;

    /* Vertex shader */
    out_vertex_shader_parts   = &m_vertex_shader_code;
    out_n_vertex_shader_parts = 1;
}

/** Prepare test specific program input for draw call
 *
 **/
void GeometryShaderMaxOutputComponentsSinglePointTest::prepareProgramInput()
{
    /* Nothing to be done here */
}

/** Verify rendered image
 *
 *  @param data Image to verify
 *
 *  @return true  Image pixels match expected values
 *          false Some pixels have wrong values
 **/
bool GeometryShaderMaxOutputComponentsSinglePointTest::verifyResult(const void *data)
{
    const unsigned char *result_image       = (const unsigned char *)data;
    const unsigned int line_size            = m_texture_width * m_texture_pixel_size;
    const glw::GLint n_components_per_point = m_n_available_vectors * 4; /* 4 components per vector */

    const glw::GLint first_value    = 1;
    const glw::GLint last_value     = n_components_per_point;
    const glw::GLint expected_value = ((first_value + last_value) * n_components_per_point) / 2;

    /* Verify all pixels that belong to point, area m_point_size x m_point_size */
    for (unsigned int y = 0; y < m_point_size; ++y)
    {
        const unsigned int line_offset = y * line_size;

        for (unsigned int x = 0; x < m_point_size; ++x)
        {
            const unsigned int texel_offset = line_offset + x * m_texture_pixel_size;

            if (0 != memcmp(result_image + texel_offset, &expected_value, sizeof(expected_value)))
            {
                const glw::GLint *result_value = (const glw::GLint *)(result_image + texel_offset);

                m_testCtx.getLog() << tcu::TestLog::Message << "Wrong result! Expected: " << expected_value
                                   << " Extracted: " << *result_value << "  X: " << x << " Y: " << y
                                   << tcu::TestLog::EndMessage;

                return false;
            }
        }
    }

    return true;
}

/** Prepare fragment shader code
 *
 *  @param out_shader_code String that will be used to store shaders code
 **/
void GeometryShaderMaxOutputComponentsSinglePointTest::prepareFragmentShader(std::string &out_shader_code) const
{
    std::stringstream stream;

    stream << m_fragment_shader_code_preamble;
    stream << m_common_shader_code_gs_fs_out_definitions;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << m_fragment_shader_code_flat_in_ivec4 << " " << m_common_shader_code_gs_fs_out << i << ";\n";
    }

    stream << m_fragment_shader_code_body_begin;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << "    " << m_fragment_shader_code_sum << m_common_shader_code_gs_fs_out << i << ".x + "
               << m_common_shader_code_gs_fs_out << i << ".y + " << m_common_shader_code_gs_fs_out << i << ".z + "
               << m_common_shader_code_gs_fs_out << i << ".w;\n";
    }

    stream << m_fragment_shader_code_body_end;

    out_shader_code = stream.str();
}

/** Prepare geometry shader code
 *
 *  @param out_shader_code String that will be used to store shaders code
 **/
void GeometryShaderMaxOutputComponentsSinglePointTest::prepareGeometryShader(std::string &out_shader_code) const
{
    std::stringstream stream;

    stream << m_geometry_shader_code_preamble;
    stream << m_common_shader_code_gs_fs_out_definitions;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << m_geometry_shader_code_flat_out_ivec4 << " " << m_common_shader_code_gs_fs_out << i << ";\n";
    }

    stream << m_geometry_shader_code_body_begin;

    for (int i = 0; i < m_n_available_vectors; ++i)
    {
        stream << "    " << m_common_shader_code_gs_fs_out << i << m_geometry_shader_code_assignment;
    }

    stream << m_geometry_shader_code_body_end;

    out_shader_code = stream.str();
}

/** Constructor
 *
 * @param context     Test context
 * @param name        Test case's name
 * @param description Test case's description
 **/
GeometryShaderMaxTextureUnitsTest::GeometryShaderMaxTextureUnitsTest(Context &context, const ExtParameters &extParams,
                                                                     const char *name, const char *description)
    : GeometryShaderLimitsRenderingBase(context, extParams, name, description)
    , m_texture_width(0)
    , m_max_texture_units(0)
{
    /* Nothing to be done here */
}

/** Clears data after draw call and result verification
 *
 **/
void GeometryShaderMaxTextureUnitsTest::clean()
{
    /* GL functions */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Bind 0 to all texture units */
    for (int i = 0; i < m_max_texture_units; ++i)
    {
        gl.activeTexture(GL_TEXTURE0 + i);
        gl.bindTexture(GL_TEXTURE_2D, 0);
    }
    gl.activeTexture(GL_TEXTURE0);

    /* Delete textures */
    for (int i = 0; i < m_max_texture_units; ++i)
    {
        gl.deleteTextures(1, &m_textures[i].texture_id);
    }

    m_textures.clear();
}

/** Get details for draw call
 *
 *  @param out_primitive_type Type of primitive that will be used by next draw call
 *  @param out_n_vertices     Number of vertices that will used with next draw call
 **/
void GeometryShaderMaxTextureUnitsTest::getDrawCallDetails(glw::GLenum &out_primitive_type, glw::GLuint &out_n_vertices)
{
    /* Draw GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT points */
    out_primitive_type = GL_POINTS;
    out_n_vertices     = m_max_texture_units;
}

/** Get dimensions and format for texture bind to color attachment 0, get format and type for glReadPixels
 *
 *  @param out_texture_format      Format for texture used as color attachment 0
 *  @param out_texture_read_format Format of data used with glReadPixels
 *  @param out_texture_read_type   Type of data used with glReadPixels
 *  @param out_texture_width       Width of texture used as color attachment 0
 *  @param out_texture_height      Height of texture used as color attachment 0
 *  @param out_texture_pixel_size  Size of single pixel in bytes
 **/
void GeometryShaderMaxTextureUnitsTest::getFramebufferDetails(
    glw::GLenum &out_texture_format, glw::GLenum &out_texture_read_format, glw::GLenum &out_texture_read_type,
    glw::GLuint &out_texture_width, glw::GLuint &out_texture_height, unsigned int &out_texture_pixel_size)
{
    out_texture_format      = GL_R32I;
    out_texture_read_format = GL_RGBA_INTEGER;
    out_texture_read_type   = GL_INT;
    out_texture_width       = m_texture_width;
    out_texture_height      = m_texture_height;
    out_texture_pixel_size  = 4 * 4;
}

void GeometryShaderMaxTextureUnitsTest::getRequiredPointSize(glw::GLfloat &out_point_size)
{
    /* This test should only run if EXT_geometry_point_size is supported */
    if (!m_is_geometry_shader_point_size_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_POINT_SIZE_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    out_point_size = (float)m_point_size;
}

/** Get parts of shaders
 *
 *  @param out_fragment_shader_parts   Array of fragment shader parts
 *  @param out_n_fragment_shader_parts Number of fragment shader parts
 *  @param out_geometry_shader_parts   Array of geometry shader parts
 *  @param out_n_geometry_shader_parts Number of geometry shader parts
 *  @param out_vertex_shader_parts     Array of vertex shader parts
 *  @param out_n_vertex_shader_parts   Number of vertex shader parts
 **/
void GeometryShaderMaxTextureUnitsTest::getShaderParts(const glw::GLchar *const *&out_fragment_shader_parts,
                                                       unsigned int &out_n_fragment_shader_parts,
                                                       const glw::GLchar *const *&out_geometry_shader_parts,
                                                       unsigned int &out_n_geometry_shader_parts,
                                                       const glw::GLchar *const *&out_vertex_shader_parts,
                                                       unsigned int &out_n_vertex_shader_parts)
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Get maximum number of texture units */
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &m_max_texture_units);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() failed for GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT pname");

    /* Number of drawn points is equal to GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT */
    m_texture_width = m_max_texture_units * m_point_size;

    /* Prepare texture units string */
    std::stringstream stream;
    stream << m_max_texture_units;
    m_max_texture_units_string = stream.str();

    /* Fragment shader parts */
    out_fragment_shader_parts   = &m_fragment_shader_code;
    out_n_fragment_shader_parts = 1;

    /* Geometry shader parts */
    m_geometry_shader_parts[0] = m_geometry_shader_code_preamble;
    m_geometry_shader_parts[1] = m_max_texture_units_string.c_str();
    m_geometry_shader_parts[2] = m_geometry_shader_code_body;

    out_geometry_shader_parts   = m_geometry_shader_parts;
    out_n_geometry_shader_parts = 3;

    /* Vertex shader parts */
    m_vertex_shader_parts[0] = m_vertex_shader_code_preamble;
    m_vertex_shader_parts[1] = m_max_texture_units_string.c_str();
    m_vertex_shader_parts[2] = m_vertex_shader_code_body;

    out_vertex_shader_parts   = m_vertex_shader_parts;
    out_n_vertex_shader_parts = 3;
}

/** Prepare test specific program input for draw call
 *
 **/
void GeometryShaderMaxTextureUnitsTest::prepareProgramInput()
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    m_textures.resize(m_max_texture_units);

    /* Prepare texture storage and fill data */
    for (int i = 0; i < m_max_texture_units; ++i)
    {
        /* (starting from 1, delta: 2) */
        m_textures[i].data = i * 2 + 1;

        /* Generate and bind texture */
        gl.genTextures(1, &m_textures[i].texture_id);
        gl.bindTexture(GL_TEXTURE_2D, m_textures[i].texture_id);

        GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create texture");

        /* Allocate and upload texture data */
        gl.texImage2D(GL_TEXTURE_2D, 0 /* level */, GL_R32I, 1 /* width */, 1 /* height */, 0 /* border */,
                      GL_RED_INTEGER, GL_INT, &m_textures[i].data);

        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

        GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create storage and fill texture with data");
    }

    /* Prepare sampler uniforms */
    for (int i = 0; i < m_max_texture_units; ++i)
    {
        /* Prepare name of sampler */
        std::stringstream stream;

        stream << "gs_texture[" << i << "]";

        /* Get sampler location */
        glw::GLint gs_texture_location = gl.getUniformLocation(m_program_object_id, stream.str().c_str());

        if (-1 == gs_texture_location || (GL_NO_ERROR != gl.getError()))
        {
            TCU_FAIL("Failed to get uniform isampler2D location");
        }

        /* Set uniform at sampler location value to index of texture unit */
        gl.uniform1i(gs_texture_location, i);

        if (GL_NO_ERROR != gl.getError())
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "Failed to set uniform at location: " << gs_texture_location
                               << " to value: " << i << tcu::TestLog::EndMessage;

            TCU_FAIL("Failed to get uniform isampler2D location");
        }
    }

    /* Bind textures to texture units */
    for (int i = 0; i < m_max_texture_units; ++i)
    {
        gl.activeTexture(GL_TEXTURE0 + i);
        gl.bindTexture(GL_TEXTURE_2D, m_textures[i].texture_id);
    }

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set texture units up");
}

/** Verify rendered image
 *
 *  @param data Image to verify
 *
 *  @return true  Image pixels match expected values
 *          false Some pixels have wrong values
 **/
bool GeometryShaderMaxTextureUnitsTest::verifyResult(const void *data)
{
    const unsigned char *result_image = (const unsigned char *)data;
    const unsigned int line_size      = m_texture_width * m_texture_pixel_size;

    /* For each drawn point */
    for (glw::GLint point = 0; point < m_max_texture_units; ++point)
    {
        const glw::GLint first_value    = m_textures[0].data;
        const glw::GLint last_value     = m_textures[point].data;
        const glw::GLint expected_value = ((first_value + last_value) * (point + 1)) / 2;
        const unsigned int point_offset = point * m_texture_pixel_size * m_point_size;

        /* Verify all pixels that belong to point, area m_point_size x m_point_size */
        for (unsigned int y = 0; y < m_point_size; ++y)
        {
            const unsigned int line_offset        = y * line_size;
            const unsigned int first_texel_offset = line_offset + point_offset;

            for (unsigned int x = 0; x < m_point_size; ++x)
            {
                const unsigned int texel_offset = first_texel_offset + x * m_texture_pixel_size;

                if (0 != memcmp(result_image + texel_offset, &expected_value, sizeof(expected_value)))
                {
                    glw::GLint *result_value = (glw::GLint *)(result_image + texel_offset);

                    m_testCtx.getLog() << tcu::TestLog::Message
                                       << "Wrong result! "
                                          "Expected: "
                                       << expected_value << " Extracted: " << *result_value << " Point: " << point
                                       << " X: " << x << " Y: " << y << tcu::TestLog::EndMessage;

                    return false;
                }
            }
        }
    }

    return true;
}

/** Constructor
 *
 * @param context     Test context
 * @param name        Test case's name
 * @param description Test case's description
 **/
GeometryShaderMaxInvocationsTest::GeometryShaderMaxInvocationsTest(Context &context, const ExtParameters &extParams,
                                                                   const char *name, const char *description)
    : TestCaseBase(context, extParams, name, description)
    , m_fragment_shader_id_for_multiple_invocations_pass(0)
    , m_geometry_shader_id_for_multiple_invocations_pass(0)
    , m_program_object_id_for_multiple_invocations_pass(0)
    , m_vertex_shader_id_for_multiple_invocations_pass(0)
    , m_fragment_shader_id_for_single_invocation_pass(0)
    , m_geometry_shader_id_for_single_invocation_pass(0)
    , m_program_object_id_for_single_invocation_pass(0)
    , m_vertex_shader_id_for_single_invocation_pass(0)
    , m_max_geometry_shader_invocations(0)
    , m_framebuffer_object_id(0)
    , m_color_texture_id(0)
    , m_texture_width(0)
    , m_vertex_array_object_id(0)
{
    /* Nothing to be done here */
}

/** Initializes GLES objects used during the test.
 *
 */
void GeometryShaderMaxInvocationsTest::initTest()
{
    /* This test should only run if EXT_geometry_shader is supported */
    if (!m_is_geometry_shader_extension_supported)
    {
        throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
    }

    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Get GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT */
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_SHADER_INVOCATIONS, &m_max_geometry_shader_invocations);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call failed for GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT");

    /* Prepare string for GL_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT */
    std::stringstream stream;
    stream << m_max_geometry_shader_invocations;
    m_max_geometry_shader_invocations_string = stream.str();

    /* Prepare gemetry shader parts for multiple invocations pass */
    const glw::GLuint n_geometry_shader_parts_for_multiple_invocations_pass = 5;

    m_geometry_shader_parts_for_multiple_invocations_pass[0] = m_geometry_shader_code_preamble;
    m_geometry_shader_parts_for_multiple_invocations_pass[1] = m_max_geometry_shader_invocations_string.c_str();
    m_geometry_shader_parts_for_multiple_invocations_pass[2] = m_geometry_shader_code_layout;
    m_geometry_shader_parts_for_multiple_invocations_pass[3] = m_geometry_shader_code_layout_invocations;
    m_geometry_shader_parts_for_multiple_invocations_pass[4] = m_geometry_shader_code_body;

    /* Prepare gemetry shader parts for single invocation pass */
    const glw::GLuint n_geometry_shader_parts_for_single_invocation_pass = 4;

    m_geometry_shader_parts_for_single_invocation_pass[0] = m_geometry_shader_code_preamble;
    m_geometry_shader_parts_for_single_invocation_pass[1] = m_max_geometry_shader_invocations_string.c_str();
    m_geometry_shader_parts_for_single_invocation_pass[2] = m_geometry_shader_code_layout;
    m_geometry_shader_parts_for_single_invocation_pass[3] = m_geometry_shader_code_body;

    /* Create program and shaders for multiple GS invocations */
    m_program_object_id_for_multiple_invocations_pass = gl.createProgram();

    m_fragment_shader_id_for_multiple_invocations_pass = gl.createShader(GL_FRAGMENT_SHADER);
    m_geometry_shader_id_for_multiple_invocations_pass = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
    m_vertex_shader_id_for_multiple_invocations_pass   = gl.createShader(GL_VERTEX_SHADER);

    /* Create program and shaders for single GS invocations */
    m_program_object_id_for_single_invocation_pass = gl.createProgram();

    m_fragment_shader_id_for_single_invocation_pass = gl.createShader(GL_FRAGMENT_SHADER);
    m_geometry_shader_id_for_single_invocation_pass = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
    m_vertex_shader_id_for_single_invocation_pass   = gl.createShader(GL_VERTEX_SHADER);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create program or shader objects");

    /* Build program for multiple GS invocations */
    if (false == buildProgram(m_program_object_id_for_multiple_invocations_pass,
                              m_fragment_shader_id_for_multiple_invocations_pass, 1, &m_fragment_shader_code,
                              m_geometry_shader_id_for_multiple_invocations_pass,
                              n_geometry_shader_parts_for_multiple_invocations_pass,
                              m_geometry_shader_parts_for_multiple_invocations_pass,
                              m_vertex_shader_id_for_multiple_invocations_pass, 1, &m_vertex_shader_code))
    {
        TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader");
    }

    /* Build program for single GS invocations */
    if (false == buildProgram(m_program_object_id_for_single_invocation_pass,
                              m_fragment_shader_id_for_single_invocation_pass, 1, &m_fragment_shader_code,
                              m_geometry_shader_id_for_single_invocation_pass,
                              n_geometry_shader_parts_for_single_invocation_pass,
                              m_geometry_shader_parts_for_single_invocation_pass,
                              m_vertex_shader_id_for_single_invocation_pass, 1, &m_vertex_shader_code))
    {
        TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader");
    }

    /* Set up texture object and a FBO */
    gl.genTextures(1, &m_color_texture_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create texture object");

    gl.genFramebuffers(1, &m_framebuffer_object_id);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create framebuffer object");

    m_texture_width = m_triangle_edge_length * m_max_geometry_shader_invocations;

    if (false == setupFramebufferWithTextureAsAttachment(m_framebuffer_object_id, m_color_texture_id, GL_RGBA8,
                                                         m_texture_width, m_texture_height))
    {
        TCU_FAIL("Failed to setup framebuffer");
    }

    /* Set up a vertex array object */
    gl.genVertexArrays(1, &m_vertex_array_object_id);
    gl.bindVertexArray(m_vertex_array_object_id);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create vertex array object");
}

/** Executes the test.
 *
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *
 *  Note the function throws exception should an error occur!
 *
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 **/
tcu::TestCase::IterateResult GeometryShaderMaxInvocationsTest::iterate()
{
    initTest();

    /* Variables used for image verification purposes */
    std::vector<unsigned char> result_image(m_texture_width * m_texture_height * m_texture_pixel_size);

    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Render with multiple GS invocations */
    gl.useProgram(m_program_object_id_for_multiple_invocations_pass);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not use program");

    gl.clearColor(255 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */);
    gl.clear(GL_COLOR_BUFFER_BIT);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not clear the color buffer");

    gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Call drawArrays() failed");

    /* Extract image from FBO */
    gl.readPixels(0 /* x */, 0 /* y */, m_texture_width, m_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, &result_image[0]);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not read back pixels from color buffer");

    /* Run verification */
    bool result_of_multiple_invocations_pass = verifyResultOfMultipleInvocationsPass(&result_image[0]);

    /* Render with single GS invocations */
    gl.useProgram(m_program_object_id_for_single_invocation_pass);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not use program");

    gl.clearColor(255 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */);
    gl.clear(GL_COLOR_BUFFER_BIT);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not clear the color buffer");

    gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
    GLU_EXPECT_NO_ERROR(gl.getError(), "Call drawArrays() failed");

    /* Extract image from FBO */
    gl.readPixels(0 /* x */, 0 /* y */, m_texture_width, m_texture_height, GL_RGBA, GL_UNSIGNED_BYTE, &result_image[0]);

    GLU_EXPECT_NO_ERROR(gl.getError(), "Could not read back pixels from color buffer");

    /* Run verification */
    bool result_of_single_invocation_pass = verifyResultOfSingleInvocationPass(&result_image[0]);

    /* Set test result */
    if (result_of_multiple_invocations_pass && result_of_single_invocation_pass)
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
    }
    else
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
    }

    return STOP;
}

/** Deinitializes GLES objects created during the test.
 *
 */
void GeometryShaderMaxInvocationsTest::deinit()
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Reset OpenGL ES state */
    gl.useProgram(0);
    gl.bindVertexArray(0);
    gl.bindTexture(GL_TEXTURE_2D, 0);
    gl.bindFramebuffer(GL_FRAMEBUFFER, 0);

    /* Delete everything */
    if (m_program_object_id_for_multiple_invocations_pass != 0)
    {
        gl.deleteProgram(m_program_object_id_for_multiple_invocations_pass);

        m_program_object_id_for_multiple_invocations_pass = 0;
    }

    if (m_fragment_shader_id_for_multiple_invocations_pass != 0)
    {
        gl.deleteShader(m_fragment_shader_id_for_multiple_invocations_pass);

        m_fragment_shader_id_for_multiple_invocations_pass = 0;
    }

    if (m_geometry_shader_id_for_multiple_invocations_pass != 0)
    {
        gl.deleteShader(m_geometry_shader_id_for_multiple_invocations_pass);

        m_geometry_shader_id_for_multiple_invocations_pass = 0;
    }

    if (m_vertex_shader_id_for_multiple_invocations_pass != 0)
    {
        gl.deleteShader(m_vertex_shader_id_for_multiple_invocations_pass);

        m_vertex_shader_id_for_multiple_invocations_pass = 0;
    }

    if (m_program_object_id_for_single_invocation_pass != 0)
    {
        gl.deleteProgram(m_program_object_id_for_single_invocation_pass);

        m_program_object_id_for_single_invocation_pass = 0;
    }

    if (m_fragment_shader_id_for_single_invocation_pass != 0)
    {
        gl.deleteShader(m_fragment_shader_id_for_single_invocation_pass);

        m_fragment_shader_id_for_single_invocation_pass = 0;
    }

    if (m_geometry_shader_id_for_single_invocation_pass != 0)
    {
        gl.deleteShader(m_geometry_shader_id_for_single_invocation_pass);

        m_geometry_shader_id_for_single_invocation_pass = 0;
    }

    if (m_vertex_shader_id_for_single_invocation_pass != 0)
    {
        gl.deleteShader(m_vertex_shader_id_for_single_invocation_pass);

        m_vertex_shader_id_for_single_invocation_pass = 0;
    }

    if (m_vertex_array_object_id != 0)
    {
        gl.deleteVertexArrays(1, &m_vertex_array_object_id);

        m_vertex_array_object_id = 0;
    }

    if (m_color_texture_id != 0)
    {
        gl.deleteTextures(1, &m_color_texture_id);

        m_color_texture_id = 0;
    }

    if (m_framebuffer_object_id != 0)
    {
        gl.deleteFramebuffers(1, &m_framebuffer_object_id);

        m_framebuffer_object_id = 0;
    }

    /* Deinitilize base class */
    TestCaseBase::deinit();
}

/** Verify image rendered during draw call for multiple invocations pass
 *
 *  @param result_image Image data
 *
 *  @return true  When image is as expected
 *          false When image is wrong
 **/
bool GeometryShaderMaxInvocationsTest::verifyResultOfMultipleInvocationsPass(unsigned char *result_image)
{
    for (unsigned int i = 0; i < (unsigned int)m_max_geometry_shader_invocations; ++i)
    {
        /* Verify that pixel at triangle's center was modified */
        const unsigned int x1 = m_triangle_edge_length * i;
        const unsigned int x2 = m_triangle_edge_length * i;
        const unsigned int x3 = m_triangle_edge_length * (i + 1) - 1;

        const unsigned int y1 = 0;
        const unsigned int y2 = m_triangle_edge_length - 1;
        const unsigned int y3 = m_triangle_edge_length - 1;

        const unsigned int center_x = (x1 + x2 + x3) / 3;
        const unsigned int center_y = (y1 + y2 + y3) / 3;

        bool is_pixel_valid = comparePixel(result_image, center_x, center_y, m_texture_width, m_texture_height,
                                           m_texture_pixel_size, 0, 255, 0, 0);

        if (false == is_pixel_valid)
        {
            m_testCtx.getLog() << tcu::TestLog::Message
                               << "Invalid pixel at "
                                  "["
                               << center_x << ";" << center_y
                               << "]! "
                                  "Triangle index: "
                               << i << " from range <0:" << m_max_geometry_shader_invocations << ")."
                               << tcu::TestLog::EndMessage;

            return false;
        }

        /* Verify that background's pixel was not modified */
        const unsigned int x4 = m_triangle_edge_length * (i + 1) - 1;
        const unsigned int y4 = m_triangle_edge_length - 1;

        is_pixel_valid =
            comparePixel(result_image, x4, y4, m_texture_width, m_texture_height, m_texture_pixel_size, 255, 0, 0, 0);

        if (false == is_pixel_valid)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "Invalid pixel at [" << x4 << ";" << y4
                               << "]! "
                                  "Background for index: "
                               << i << "from range <0:" << m_max_geometry_shader_invocations << ")."
                               << tcu::TestLog::EndMessage;

            return false;
        }
    }

    return true;
}

/** Verify image rendered during draw call for single invocation pass
 *
 *  @param result_image Image data
 *
 *  @return true  When image is as expected
 *          false When image is wrong
 **/
bool GeometryShaderMaxInvocationsTest::verifyResultOfSingleInvocationPass(unsigned char *result_image)
{
    /* Only one triangle should be drawn, verify that pixel at its center was modified */
    {
        const unsigned int x1 = 0;
        const unsigned int x2 = 0;
        const unsigned int x3 = m_triangle_edge_length - 1;

        const unsigned int y1 = 0;
        const unsigned int y2 = m_triangle_edge_length - 1;
        const unsigned int y3 = m_triangle_edge_length - 1;

        const unsigned int center_x = (x1 + x2 + x3) / 3;
        const unsigned int center_y = (y1 + y2 + y3) / 3;

        bool is_pixel_valid = comparePixel(result_image, center_x, center_y, m_texture_width, m_texture_height,
                                           m_texture_pixel_size, 0, 255, 0, 0);

        if (false == is_pixel_valid)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "Invalid pixel at [" << center_x << ";" << center_y
                               << "]! "
                                  "Triangle index: "
                               << 0 << " from range <0:" << m_max_geometry_shader_invocations << ")."
                               << tcu::TestLog::EndMessage;

            return false;
        }

        /* Verify that background's pixel was not modified */
        const unsigned int x4 = m_triangle_edge_length - 1;
        const unsigned int y4 = m_triangle_edge_length - 1;

        is_pixel_valid =
            comparePixel(result_image, x4, y4, m_texture_width, m_texture_height, m_texture_pixel_size, 255, 0, 0, 0);

        if (false == is_pixel_valid)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "Invalid pixel at [" << x4 << ";" << y4
                               << "]! "
                                  "Background for index: "
                               << 0 << " from range <0:" << m_max_geometry_shader_invocations << ")."
                               << tcu::TestLog::EndMessage;

            return false;
        }
    }

    for (unsigned int i = 1; i < (unsigned int)m_max_geometry_shader_invocations; ++i)
    {
        /* Verify that pixel at triangle's center was not modified */
        const unsigned int x1 = m_triangle_edge_length * i;
        const unsigned int x2 = m_triangle_edge_length * i;
        const unsigned int x3 = m_triangle_edge_length * (i + 1) - 1;

        const unsigned int y1 = 0;
        const unsigned int y2 = m_triangle_edge_length - 1;
        const unsigned int y3 = m_triangle_edge_length - 1;

        const unsigned int center_x = (x1 + x2 + x3) / 3;
        const unsigned int center_y = (y1 + y2 + y3) / 3;

        bool is_pixel_valid = comparePixel(result_image, center_x, center_y, m_texture_width, m_texture_height,
                                           m_texture_pixel_size, 255, 0, 0, 0);

        if (false == is_pixel_valid)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "Invalid pixel at [" << center_x << ";" << center_y
                               << "]! "
                                  "Triangle index: "
                               << i << " from range <0:" << m_max_geometry_shader_invocations << ")."
                               << tcu::TestLog::EndMessage;

            return false;
        }

        /* Verify that background's pixel was not modified */
        const unsigned int x4 = m_triangle_edge_length * (i + 1) - 1;
        const unsigned int y4 = m_triangle_edge_length - 1;

        is_pixel_valid =
            comparePixel(result_image, x4, y4, m_texture_width, m_texture_height, m_texture_pixel_size, 255, 0, 0, 0);

        if (false == is_pixel_valid)
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "Invalid pixel at [" << x4 << ";" << y4
                               << "]! "
                                  "Background for index: "
                               << i << " from range <0:" << m_max_geometry_shader_invocations << ")."
                               << tcu::TestLog::EndMessage;

            return false;
        }
    }

    return true;
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's description
 **/
GeometryShaderMaxCombinedTextureUnitsTest::GeometryShaderMaxCombinedTextureUnitsTest(Context &context,
                                                                                     const ExtParameters &extParams,
                                                                                     const char *name,
                                                                                     const char *description)
    : GeometryShaderLimitsRenderingBase(context, extParams, name, description)
    , m_texture_width(0)
    , m_max_combined_texture_units(0)
    , m_max_fragment_texture_units(0)
    , m_max_geometry_texture_units(0)
    , m_max_vertex_texture_units(0)
    , m_min_texture_units(0)
    , m_n_fragment_texture_units(0)
    , m_n_geometry_texture_units(0)
    , m_n_texture_units(0)
    , m_n_vertex_texture_units(0)
{
    /* Nothing to be done here */
}

/** Clears data after draw call and result verification
 *
 **/
void GeometryShaderMaxCombinedTextureUnitsTest::clean()
{
    /* GL functions */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Bind 0 to all texture units */
    for (int i = 0; i < m_n_texture_units; ++i)
    {
        gl.activeTexture(GL_TEXTURE0 + i);
        gl.bindTexture(GL_TEXTURE_2D, 0);
    }

    /* Delete textures */
    for (int i = 0; i < m_n_texture_units; ++i)
    {
        gl.deleteTextures(1, &m_textures[i].texture_id);
    }

    m_textures.clear();
}

/** Get details for draw call
 *
 *  @param out_primitive_type Type of primitive that will be used by next draw call
 *  @param out_n_vertices     Number of vertices that will used with next draw call
 **/
void GeometryShaderMaxCombinedTextureUnitsTest::getDrawCallDetails(glw::GLenum &out_primitive_type,
                                                                   glw::GLuint &out_n_vertices)
{
    /* Draw GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT points */
    out_primitive_type = GL_POINTS;
    out_n_vertices     = m_min_texture_units;
}

/** Get dimensions and format for texture bind to color attachment 0, get format and type for glReadPixels
 *
 *  @param out_texture_format      Format for texture used as color attachment 0
 *  @param out_texture_read_format Format of data used with glReadPixels
 *  @param out_texture_read_type   Type of data used with glReadPixels
 *  @param out_texture_width       Width of texture used as color attachment 0
 *  @param out_texture_height      Height of texture used as color attachment 0
 *  @param out_texture_pixel_size  Size of single pixel in bytes
 **/
void GeometryShaderMaxCombinedTextureUnitsTest::getFramebufferDetails(
    glw::GLenum &out_texture_format, glw::GLenum &out_texture_read_format, glw::GLenum &out_texture_read_type,
    glw::GLuint &out_texture_width, glw::GLuint &out_texture_height, unsigned int &out_texture_pixel_size)
{
    out_texture_format      = GL_R32UI;
    out_texture_read_format = GL_RGBA_INTEGER;
    out_texture_read_type   = GL_UNSIGNED_INT;
    out_texture_width       = m_texture_width;
    out_texture_height      = m_texture_height;
    out_texture_pixel_size  = 4 * 4;
}

void GeometryShaderMaxCombinedTextureUnitsTest::getRequiredPointSize(glw::GLfloat &out_point_size)
{
    out_point_size = (float)m_point_size;
}

/** Get parts of shaders
 *
 *  @param out_fragment_shader_parts   Array of fragment shader parts
 *  @param out_n_fragment_shader_parts Number of fragment shader parts
 *  @param out_geometry_shader_parts   Array of geometry shader parts
 *  @param out_n_geometry_shader_parts Number of geometry shader parts
 *  @param out_vertex_shader_parts     Array of vertex shader parts
 *  @param out_n_vertex_shader_parts   Number of vertex shader parts
 **/
void GeometryShaderMaxCombinedTextureUnitsTest::getShaderParts(const glw::GLchar *const *&out_fragment_shader_parts,
                                                               unsigned int &out_n_fragment_shader_parts,
                                                               const glw::GLchar *const *&out_geometry_shader_parts,
                                                               unsigned int &out_n_geometry_shader_parts,
                                                               const glw::GLchar *const *&out_vertex_shader_parts,
                                                               unsigned int &out_n_vertex_shader_parts)
{
    /* GL functions */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    /* Get maximum number of texture units */
    gl.getIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &m_max_combined_texture_units);
    gl.getIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &m_max_vertex_texture_units);
    gl.getIntegerv(m_glExtTokens.MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &m_max_geometry_texture_units);
    gl.getIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &m_max_fragment_texture_units);
    GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call(s) failed");

    m_n_texture_units =
        de::max(m_max_vertex_texture_units, de::max(m_max_geometry_texture_units, m_max_fragment_texture_units));
    m_n_vertex_texture_units = de::max(1, de::min(m_max_combined_texture_units - 2, m_max_vertex_texture_units));
    m_n_fragment_texture_units =
        de::max(1, de::min(m_max_combined_texture_units - m_n_vertex_texture_units - 1, m_max_fragment_texture_units));
    m_n_geometry_texture_units =
        de::max(1, de::min(m_max_combined_texture_units - m_n_vertex_texture_units - m_n_fragment_texture_units,
                           m_max_geometry_texture_units));
    m_min_texture_units =
        de::min(m_n_vertex_texture_units, de::min(m_n_fragment_texture_units, m_n_geometry_texture_units));

    /* Number of drawn points is equal to GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT */
    m_texture_width = m_n_texture_units * m_point_size;

    /* Prepare texture units string */
    std::stringstream stream_fragment;
    stream_fragment << m_n_fragment_texture_units;
    m_n_fragment_texture_units_string = stream_fragment.str();

    std::stringstream stream_geometry;
    stream_geometry << m_n_geometry_texture_units;
    m_n_geometry_texture_units_string = stream_geometry.str();

    std::stringstream stream_vertex;
    stream_vertex << m_n_vertex_texture_units;
    m_n_vertex_texture_units_string = stream_vertex.str();

    /* Fragment shader parts */
    m_fragment_shader_parts[0] = m_fragment_shader_code_preamble;
    m_fragment_shader_parts[1] = m_n_fragment_texture_units_string.c_str();
    m_fragment_shader_parts[2] = m_fragment_shader_code_body;

    out_fragment_shader_parts   = m_fragment_shader_parts;
    out_n_fragment_shader_parts = 3;

    /* Geometry shader parts */
    m_geometry_shader_parts[0] = m_geometry_shader_code_preamble;
    m_geometry_shader_parts[1] = m_n_geometry_texture_units_string.c_str();
    m_geometry_shader_parts[2] = m_geometry_shader_code_body;

    out_geometry_shader_parts   = m_geometry_shader_parts;
    out_n_geometry_shader_parts = 3;

    /* Vertex shader parts */
    m_vertex_shader_parts[0] = m_vertex_shader_code_preamble;
    m_vertex_shader_parts[1] = m_n_vertex_texture_units_string.c_str();
    m_vertex_shader_parts[2] = m_vertex_shader_code_body;

    out_vertex_shader_parts   = m_vertex_shader_parts;
    out_n_vertex_shader_parts = 3;
}

/** Prepare test specific program input for draw call
 *
 **/
void GeometryShaderMaxCombinedTextureUnitsTest::prepareProgramInput()
{
    /* Retrieve ES entry-points */
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();

    m_textures.resize(m_n_texture_units);

    /* Prepare texture storage and fill data */
    for (int i = 0; i < m_n_texture_units; ++i)
    {
        /* Reset texture data to 0 after each 16 iterations */
        m_textures[i].data = i % 16;

        /* Generate and bind texture */
        gl.genTextures(1, &m_textures[i].texture_id);
        gl.bindTexture(GL_TEXTURE_2D, m_textures[i].texture_id);

        GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create texture");

        /* Allocate and upload texture data */
        gl.texImage2D(GL_TEXTURE_2D, 0 /* level */, GL_R32UI, 1 /* width*/, 1 /* height */, 0 /* border */,
                      GL_RED_INTEGER, GL_UNSIGNED_INT, &m_textures[i].data);

        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);

        GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create storage and fill texture with data");
    }

    /* Prepare sampler uniforms */
    for (int i = 0; i < m_n_texture_units; ++i)
    {
        /* Prepare name of sampler */
        std::stringstream stream;

        stream << "sampler[" << i << "]";

        /* Get sampler location */
        glw::GLint sampler_location = gl.getUniformLocation(m_program_object_id, stream.str().c_str());

        if (-1 == sampler_location || GL_NO_ERROR != gl.getError())
        {
            TCU_FAIL("Failed to get uniform usampler2D location");
        }

        /* Set uniform at sampler location value to index of texture unit */
        gl.uniform1i(sampler_location, i);

        if (GL_NO_ERROR != gl.getError())
        {
            m_testCtx.getLog() << tcu::TestLog::Message << "Failed to set uniform at location: " << sampler_location
                               << " to value: " << i << tcu::TestLog::EndMessage;

            TCU_FAIL("Failed to get uniform isampler2D location");
        }
    }

    /* Bind textures to texture units */
    for (int i = 0; i < m_n_texture_units; ++i)
    {
        gl.activeTexture(GL_TEXTURE0 + i);
        gl.bindTexture(GL_TEXTURE_2D, m_textures[i].texture_id);

        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    }

    GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set texture units up");
}

/** Verify rendered image
 *
 *  @param data Image to verify
 *
 *  @return true  Image pixels match expected values
 *          false Some pixels have wrong values
 **/
bool GeometryShaderMaxCombinedTextureUnitsTest::verifyResult(const void *data)
{
    const unsigned char *result_image = (const unsigned char *)data;
    const unsigned int line_size      = m_texture_width * m_texture_pixel_size;

    /* For each drawn point */
    for (glw::GLint point = 0; point < m_n_texture_units; ++point)
    {
        const unsigned int last_vertex_index = de::min(point, m_n_vertex_texture_units);

        glw::GLint expected_vertex_value   = 0;
        glw::GLint expected_geometry_value = 0;
        glw::GLint expected_fragment_value = 0;

        for (unsigned int i = 0; i < last_vertex_index; ++i)
        {
            expected_vertex_value += m_textures[i].data;
        }

        for (unsigned int i = 0; i < last_vertex_index; ++i)
        {
            expected_geometry_value += m_textures[i].data;
        }

        for (unsigned int i = 0; i < last_vertex_index; ++i)
        {
            expected_fragment_value += m_textures[i].data;
        }

        const glw::GLint expected_value = expected_vertex_value + expected_geometry_value + expected_fragment_value;
        const unsigned int point_offset = point * m_texture_pixel_size * m_point_size;

        /* Verify all pixels that belong to point, area m_point_size x m_point_size */
        for (unsigned int y = 0; y < m_point_size; ++y)
        {
            const unsigned int line_offset        = y * line_size;
            const unsigned int first_texel_offset = line_offset + point_offset;

            for (unsigned int x = 0; x < m_point_size; ++x)
            {
                const unsigned int texel_offset = first_texel_offset + x * m_texture_pixel_size;

                if (0 != memcmp(result_image + texel_offset, &expected_value, sizeof(expected_value)))
                {
                    glw::GLint *result_value = (glw::GLint *)(result_image + texel_offset);

                    m_testCtx.getLog() << tcu::TestLog::Message
                                       << "Wrong result!"
                                          " Expected: "
                                       << expected_value << " Extracted: " << *result_value << " Point: " << point
                                       << " X: " << x << " Y: " << y << tcu::TestLog::EndMessage;

                    return false;
                }
            }
        }
    }

    return true;
}

} // namespace glcts